如何合并多个类，生成一个新类？

Question

为了适应需求，要灵活地组合出新的商业逻辑，
如何合并多个类，生成一个新类？比如把，
class ItemMasterBLL() { DataTable GetItemList(); DataRow GetItemInfo(); bool DeleteItem(); }
class UnitMasterBLL() { DataTable GetUnitList(); DataRow GetUnitInfo(); bool DeleteUnit(); }
class VendorMasterBLL() { DataTable GetVendorList(); DataRow GetVendorInfo(); bool DeleteVendor(); }
合并成(要合并的这几个类没有重复的成员)：
class ItemManagementBLL()
{
  //
  DataTable GetItemList();
  DataRow GetItemInfo();
  bool DeleteItem();
  //
  DataTable GetUnitList();
  DataRow GetUnitInfo();
  bool DeleteUnit();
  //
  DataTable GetVendorList();
  DataRow GetVendorInfo();
  bool DeleteVendor();
}
但原有类仍需正常使用。问题是类只能单个继承，不然就不存在此问题了：
class ItemManagementBLL() : ItemMasterBLL, ItemTypeBLL, UnitMasterBLL
class OrderManagementBLL() : OrderBillBLL, CustomerMasterBLL, ItemMasterBLL, CurrencyMasterBLL, UnitMasterBLL
搞软件的一般都有“偷懒”的思想，想改了基类，合并类不需做任何改动而自动跟着变。
现在只想到用反射的方法在一个小程序中生成合并类的代码文本(如下)，并手工贴到工程代码中：
class ItemManagementBLL()
{
  //
  ItemMasterBLL itemMasterBLL= new ItemMasterBLL();
  DataTable GetItemList() { return itemMasterBLL.GetItemList(); }
  DataRow GetItemInfo() { return itemMasterBLL.GetItemInfo(); }
  bool DeleteItem() { return itemMasterBLL.DeleteItem(); }
  //
  UnitMasterBLL UnitMasterBLL= new UnitMasterBLL();
  DataTable GetUnitList() { return UnitMasterBLL.GetUnitList(); }
  DataRow GetUnitInfo() { return UnitMasterBLL.GetUnitInfo(); }
  bool DeleteUnit() { return UnitMasterBLL.DeleteUnit(); }
  //
  VendorMasterBLL VendorMasterBLL= new VendorMasterBLL();
  DataTable GetVendorList() { return VendorMasterBLL.GetVendorList(); }
  DataRow GetVendorInfo() { return VendorMasterBLL.GetVendorInfo(); }
  bool DeleteVendor() { return VendorMasterBLL.DeleteVendor(); }
}

Answer 1

以前是合部写在一个类中：//ItemBLL.cs
public partial Project1BLL
{
  DataTable GetItemList(){}
  DataRow GetItemInfo(){}
  bool DeleteItem(){}
}//UnitBLL.cs
public partial Project1BLL
{
  DataTable GetUnitList(){}
  DataRow GetUnitInfo(){}
  bool DeleteUnit(){}
}但后面发现把整个项目需要的东东合部写在一个类中，太宠大了吧。如果分别散开的话，操作又很麻烦：
class OrderForm()
{
  OrderBillBLL ordBLL = new OrderBillBLL ();
  CustomerMasterBLL custBLL = new CustomerMasterBLL ();
  ItemMasterBLL itemBLL = new ItemMasterBLL ();
  
  public OrderForm(){}
}

Answer 2

class ItemMasterBLL:IItemMaster
class UnitMasterBLL:IUnitMaster
class VendorMasterBLL:IVendorMaster class C:IItemMaster,IUnitMaster,IVendorMaster
 {
    private ItemMasterBLL _sItem;
    private UnitMasterBLL _sUnit;
    private VendorMasterBLL _sVendor;    #region IItemMaster的接口函数
    public DataTable GetItemList(){return _sItme.GetItemList();}
    public DataRow GetItemInfo(){return _sItem.GetItemInfo();}
    public bool DeleteItem(){return _sItem.DeleteItem();}
    #endregion
    //剩下的一样 代理一下就可以了
 }

Answer 3

如果怕改动以前的源码 那就做适配 来中间过渡了...  class ItemMasterAdapter ItemMasterBLL,IItemMaster;  //后边继续保持代理
  class C:IItemMaster,IUnitMaster,IVendorMaster
  {
      private ItemMasterAdapter _sItem;
    
    #region IItemMaster的接口函数
      public DataTable GetItemList(){return _sItme.GetItemList();}
      public DataRow GetItemInfo(){return _sItem.GetItemInfo();}
      public bool DeleteItem(){return _sItem.DeleteItem();}
    #endregion
  }

Answer 4

BLL的“庞大”是必然的。BLL本身并不是业务实体对象，而只是系统的一堆对外api接口方法。一个应用系统，提供几百个BLL方法供外部各种应用来调用，很正常。BLL跟传统的函数库、方法库概念完全一样。实际上，如果仅仅是内部调用（没有其它特殊要求），几百个BLL方法都定义为static方法然后放在一个文件中就可以了。

Answer 5

通常所说的“面向对象的分析和设计”，是从系统内部逻辑系统来说的。这时往往抛开计算机领域的概念来设计。而BLL并不是这个角度，BLL是面向客户端接口层，例如面向你的通信机制来封装各个Command（更有甚者可能你需要为几百个BLL方法每一个都重新构造为独立的Command模式对象）。这是无法避开的一层。对待这一层我们以传统的方式实现为好，它的目的就是很好地将内外层隔离开，以便内部进行巨大的变化也不会影响外部客户端调用。

Answer 6

--------------------------------------------------------------
2楼说的不但没简化，反而多了个约束(接口)。--------------------------------------------------------------
>>按特性合理的分类。
>>合理的继承。但要保证类之间的关联降到最低(低耦合)
>>不主张一个项目一个类，包罗万象的做法很难维护。
此贴就是想问怎么解决如上问题。
MasterManagement、 SalesManagement、 InventoryManagement等都会用到 IItem(或ItemDAL).GetItemInfo()方法，不知怎么把这些公共方法提供到最后的BLL中最合适。--------------------------------------------------------------
如果合到静态类中，
public class ItemManagementBLL()
{
  public static ItemMasterBLL item = new ItemMasterBLL();
  public static UnitMasterBLL unit = new UnitMasterBLL();
  public static VendorMasterBLL vendor = new VendorMasterBLL();
}这样调用也太麻烦了，至少多了顶“ItemManagementBLL.”帽子：
private DoIt()
{
  DataTable dt = ItemManagementBLL.item.GetItemList();
}--------------------------------------------------------------

Answer 7

写一个简单的小程序希望对你解决这个问题有帮助
using System;
using System.Collections.Generic;
using System.Text;namespace ConsoleApplication3
{
    class Program
    {
        static void Main(string[] args)
        {
            Class3 test = new Class3();
            test.F1F();
            test.F2F();
            Console.ReadKey();
        }
    }
}namespace ConsoleApplication3
{
    public class Class1
    {
        public void F1F()
        {
            Console.Out.WriteLine("F1");
        }
    }
}namespace ConsoleApplication3
{
    public class Class2
    {
        public void F2F()
        {
            Console.Out.WriteLine("F2");
        }
    }
}
namespace ConsoleApplication3
{
    public class Class3
    {
        Class1 FF1;
        Class2 FF2;
        public Class3()
        {
            this.FF1 = new Class1();
            this.FF2 = new Class2();
        }
        public void F1F()
        {
            this.FF1.F1F();
        }
        public void F2F()
        {
            this.FF2.F2F();
        }
    }
}

Answer 8

看来只有用楼上的这种方法了。
即在SalesOrderBll模块中加成员来分别实例化ItemBll、UnitBll、CurrencyBll、CustomerBll、EmployerBll、UserBll、...(一大堆)

Answer 9

小case，你写个类，里面实例化这些类，调用它们的方法，相当于包装一下

Answer 10

改进一下，这样总该行了。这样 ItemBll直接或间接引用ItemBll自己都行。namespace ConsoleApplication3
{
    public class Class3
    {        private Class1 _FF1 = null;
        public Class1 FF1
        {
            get 
            {
                if (_FF1==null) _FF1 = new Class1();
                return _FF1;
            }
        }        private Class2 _FF2 = null;
        public Class1 FF2
        {
            get 
            {
                if (_FF2==null) _FF2 = new Class2();
                return _FF2;
            }
        }        public Class3()
        {
        }        public void F1F()
        {
            this.FF1.F1F();
        }
        public void F2F()
        {
            this.FF2.F2F();
        }
    }
}