动态添加新方法、属性到现有类中所需的帮助

Question

我不确定在Dot Net中是否可以实现这种实现。以下是信息

目前我们正在开发一个使用 COM+、ASP、XSL、XML 技术完成的应用程序。它是一个多层体系结构应用程序，其中 COM+ 充当 BAL。任何 CRUD 操作的执行步骤都将使用单独的 UI 进行定义，该 UI 使用 XML 来存储信息。 BAL读取XML并理解定义的执行步骤并执行DLL中相应的方法。与 EDM 非常相似，我们有自定义模型（使用 XML），它确定对象的哪些属性是可搜索、可检索等。BAL 基于此信息构造查询并调用过程来获取数据。

在当前的应用程序中，BAL 和 DAL 都可以高度自定义，无需更改任何代码。结果将以 XML 格式传输到表示层，表示层根据收到的数据构建 UI。

现在我正在创建一个处理员工信息的迁移项目。它还将遵循 N 层架构，其中表示层与 BAL 通信，BAL 连接到 DAL 以返回数据。

问题是，在我们现有的版本中，我们将每个信息以其本机形式处理为 XML（没有对象转换等），但是在迁移项目中，团队确实对利用 OOP 开发模型感兴趣，其中每个信息都是从 BAL 发送的数据需要转换为其各自类型的对象（例如 employeeCollection、Address Collection 等）。

如果我们有从 BAL 返回的静态数据数量，我们可以有一个包含这些节点作为属性的类，并且我们可以访问它们。但在我们的例子中，从 BAL 返回的数据需要定制。我们如何处理表示层中的定制，将结果转换为对象。

下面是返回的 XML 示例。

<employees>
    <employee>
        <firstName>Employee 1 First Name</firstName>
        <lastName>Employee 1 Last Name</lastName>
        <addresses>
            <address>
                <addressType>1</addressType>
                <StreetName>Street name1</StreetName>
                <RegionName>Region name</RegionName>
            <address>
            <address>
                <addressType>2</addressType>
                <StreetName>Street name2</StreetName>
                <RegionName>Region name</RegionName>
            <address>
            <address>
                <addressType>3</addressType>
                <StreetName>Street name3</StreetName>
                <RegionName>Region name</RegionName>
            <address>
        <addresses>
    </employee>
    <employee>
        <firstName>Employee 2 First Name</firstName>
        <lastName>Employee 2 Last Name</lastName>
        <addresses>
            <address>
                <addressType>1</addressType>
                <StreetName>Street name1</StreetName>
                <RegionName>Region name</RegionName>
            <address>
            <address>
                <addressType>2</addressType>
                <StreetName>Street name2</StreetName>
                <RegionName>Region name</RegionName>
            <address>
        <addresses>
    </employee>
</employees>

如果这些是唯一的列，那么我可以编写一个类，

public class Address{
    public int AddressType {get;set;};
    public string StreetName {get;set;};
    public string RegionName {get;set;};
}

public class Employee{
    public string  FirstName {get; set;}
    public string  LastName {get; set;}
    public string  AddressCollection {get; set;}
}

public class EmployeeCollection : List<Employee>{
    public bool Add (Employee Data){
    ....
    }
}

public class AddressCollection : List<Address>{
    public bool Add (Address Data){
    ....
    }
}

该类将作为 DLL 提供给客户和顾问。我们不会提供相同的源代码。

现在，当顾问或客户进行定制时（例如添加国家/地区地址以及添加带有员工对象的护照信息对象），他们必须能够访问这些类中的这些属性，但如果没有源代码，他们将无法进行这些修改。使应用程序无用。有什么办法可以在 DotNet 中完成这个任务吗？

我想过使用匿名类，但是匿名类的问题是

我们不能在其中包含方法。 我不确定如何适合集合对象（这将成为一个匿名类） 不确定数据网格/用户控件绑定等。

我还考虑过使用 CODEDom 来创建运行时类，但不确定内存、性能问题。此外，这些类只能创建一次，并且必须使用相同的类，直到发生另一次更改为止。

请帮助我解决这个问题。任何类型的帮助材料/神秘代码/链接都会有所帮助。

更新：

感谢您提供的答案，这些答案使我能够研究我没有想到的不同领域。

我在问题中错过了一项信息。 UI 代码也将作为 DLL 而不是源代码。客户可以自由创建新代码并附加到 UI，但不能通过代码更改现有 UI。我们有一个设计器，它将显示可选择的、可显示的属性，客户可以从中选择向用户显示数据。这样他们就可以改变用户界面的外观和感觉。他们还可以使用此模型更改绑定属性。

如果我在问题中给出了这篇文章，我可能会得到更多答案，并且可能会让您清楚地了解到底发生了什么。

有了上面的内容，下面是我的新想法，

我还在考虑使用 CodeDom 模型单独创建类并将其迁移到 UI。下面是我的想法：

创建一个控制台应用程序来读取我们结构的 XML 文件。它将包含系统中可用的属性和类。还创建一个 UI 来操作 XML 文件来创建类。在控制台中使用 COdeDom 生成类和方法。使用库或 shell 命令编译它们。将创建的类移动到UI中，现在UI将识别新的类并可以显示属性。

这可能不会造成任何内存占用和高内存利用率/泄漏。我们还替换了 DLL，这很简单。唯一的问题是班级的产生。它必须以团队能够在此 UI 中执行任何操作的方式复杂化。你们觉得怎么样

Answer 1

如果您允许他们从您的基类继承新的 Address 和 Employee 类，那么应该可以解决问题。

public class Employee
{
  public string FirstName { get; set; }
  public string LastName { get; set; }
  public string AddressCollection { get; set; }
}

public class EmployeeCollection<T> : List<T> where T : Employee
{
  public bool Add(T Data)
  {
    return this.Add(Data);
  }
}

那么派生员工将看起来像这样

public class EmployeePlus : Employee
{
  public string PassportNo { get; set; }
}

如果您希望强类型集合是 EmployeePlus 您可以像这样简单地定义您的集合，如果您需要...

public class EmployeeCollection<T> : List<T> where T : Employee
{
  public bool Add(T Data)
  {
    return this.Add(Data);
  }
}

现在可以将 Employee 和派生对象的强类型集合用作如下

EmployeeCollection<EmployeePlus> employees = 
  new EmployeeCollection<EmployeePlus>();

Answer 2

尝试使用 MSIL

public class RunTimeObject<T> where T : class
{

    void EmitGetter(MethodBuilder methodBuilder, FieldBuilder fieldBuilder)
    {
        ILGenerator ilGenerator = methodBuilder.GetILGenerator();
        ilGenerator.Emit(OpCodes.Ldarg_0);
        ilGenerator.Emit(OpCodes.Ldfld, fieldBuilder);
        ilGenerator.Emit(OpCodes.Ret);
    }

    void EmitSetter(MethodBuilder methodBuilder, FieldBuilder fieldBuilder)
    {
        ILGenerator ilGenerator = methodBuilder.GetILGenerator();
        ilGenerator.Emit(OpCodes.Ldarg_0);
        ilGenerator.Emit(OpCodes.Ldarg_1);
        ilGenerator.Emit(OpCodes.Stfld, fieldBuilder);
        ilGenerator.Emit(OpCodes.Ret);
    }

    public object CreateNewObject(T obj)
    {

        AssemblyName assemblyName = new AssemblyName { Name = "assembly" };
        AssemblyBuilder assemblyBuilder = Thread.GetDomain().DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
        ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("module");
        TypeBuilder typeBuilder = moduleBuilder.DefineType("DynamicType", TypeAttributes.Public | TypeAttributes.Class);

        foreach (var prop in obj.GetType().GetProperties())
        {
            FieldBuilder field = typeBuilder.DefineField("_" + prop.Name, typeof(string), FieldAttributes.Private);

            PropertyBuilder propertyBuilder =
                typeBuilder.DefineProperty(prop.Name,
                                 PropertyAttributes.None,
                                 typeof(string),
                                 new Type[] { typeof(string) });

            MethodAttributes methodAttributes =
                MethodAttributes.Public |
                MethodAttributes.HideBySig;

            MethodBuilder methodBuilderGetter =
                typeBuilder.DefineMethod("get_value",
                                           methodAttributes,
                                           typeof(string),
                                           Type.EmptyTypes);

            EmitGetter(methodBuilderGetter, field);


            MethodBuilder methodBuilderSetter =
                typeBuilder.DefineMethod("set_value",
                                           methodAttributes,
                                           null,
                                           new Type[] { typeof(string) });

            EmitSetter(methodBuilderSetter, field);


            propertyBuilder.SetGetMethod(methodBuilderGetter);
            propertyBuilder.SetSetMethod(methodBuilderSetter);
        }

        Type dynamicType = typeBuilder.CreateType();

        var dynamicObject = Activator.CreateInstance(dynamicType);

        var properties = dynamicType.GetProperties();

        int count = 0;

        foreach (var item in obj.GetType().GetProperties())
            properties[count++].SetValue(dynamicObject, item.GetValue(obj, null), null);

        return dynamicObject;

    }
}

Answer 3

这似乎是一个相当奇怪的设置，但是有很多方法可以实现您想要的功能：

• 类继承（可能使
  你的基类抽象但是
  部分类是另一种选择）
• 使用接口而不是类并让您的客户
  担心实现
• 扩展方法 (ref1、ref2），通常用于
  扩展第三方代码，但不是
  通常预计会被使用。
• 装饰器

通常来说，我希望以您的方式使用接口场景，但如果您也尝试混合行为，我会冒险猜测此时重构可能会太痛苦，而类继承就是您最终的结果。