我可以声明一个 Type类型的变量吗？编译时不指定T？

Question

如何动态加载“MyContent”类？ 我有 1 个 interface、1 个抽象通用 class 和 1 个类。检查我的代码：

public interface IMyObjectInterface{
}
public abstract MyAbstractObject : IMyObjectInterface{
}
public class MyObject : MyAbstractObject{
}

public interface IMyContentInterface<T>  where T : MyAbstractObject
{
  void MyMethod();
}
public abstract MyAbstractContent<T>, IMyContentInterface<T>  where T : MyAbstractObject
{
  public abstract void MyMethod();
}
public public class MyContent : MyAbstractContent<MyObject>
{
  public override void MyMethod() { //do something }
}

我正在尝试，但显然它不起作用：

IMyObjectInterface obj = (IMyObjectInterface)Assembly.Load("MyAssembly").CreateInstance("MyObject");
IMyContentInterface<obj> content = (IMyContentInterface<obj>)Assembly.Load("MyAssembly").CreateInstance("MyContent");
content.MyMethod();
//assembly and type names are correct

如果我将 IMyContentInterface 更改为 IMyContentInterface，则有效：

IMyContentInterface<MyObject> content = (IMyContentInterface<MyObject>)Assembly.Load("MyAssembly").CreateInstance("MyContent");
content.MyMethod();
//assembly and type names are correct

问题是我不'定义 IMyContentInterface 时，第二行中的对象是什么。请问，有人知道如何在 .NET Framework 4.0 中做到这一点吗？

Answer 1

< 中的项目> 必须是类型而不是对象。

我的汽车是汽车类型的对象，所以

Car myCar=new Car();

我想要一个列表来保存我的汽车（汽车类型的对象）。

List<Car> myCars = new List<Car>();

然后我们将汽车类型的对象添加到我的列表中。

 myCars.Add(myCar);
 myCars.Add(anotherCar);

Answer 2

如何动态加载“MyContent”类？

加载并不难 - 您已经知道如何做到这一点，但 C# 泛型是强类型的，在编译时进行检查和保证。考虑以下代码：

List<string> list = new List<string>(); 
list.Add(new TcpSocket()); // This line won't compile

如果允许您像这样声明泛型，C# 编译器无法告诉您这是非法的：

Type type = GetTypeFromReflectedAssembly();
List<type> list = new List<type>();

// This *might* work - who knows?
list.Add(new TcpSocket());

如果您的最终目标是调用 MyContent.MyMethod() 并且没有与泛型类型参数 有关的任何内容，请考虑声明一个可以在继承层次结构中的某个位置实现的非泛型接口，并使用该接口声明实例变量：

IMyContentInterface content = (IMyContentInterface)Assembly.Load("MyAssembly").CreateInstance("MyContent");
content.MyMethod();

Answer 3

我读了几遍这篇文章，但我明白了你在问什么。 :) 这个问题是另一个问题的具体实例：

• 将实例化的 System.Type 作为泛型类的类型参数传递

也就是说，下面是一个示例，说明如何将它用于测试用例。显然你可以改变它。另外，不要错过我在本答案末尾的最后注释。

Assembly MyCompany.MyProduct.MyComponent：

在此程序集中定义接口：

namespace MyCompany.MyProduct.MyComponent
{
    public interface IMyObjectInterface
    {
        void MyObjectMethod();
    }

    /* It's important to include this non-generic interface as a base for
     * IMyContentInterface<T> because you will be able to reference this
     * in the assembly where you load components dynamically.
     */
    public interface IMyContentInterface
    {
        Type ObjectType
        {
            get;
        }

        void MyContentMethod();
    }

    public interface IMyContentInterface<T> : IMyContentInterface
        where T : IMyObjectInterface
    {
    }
}

Assembly MyCompany.MyProduct.MyComponent.Implementation：

在此程序集中实现将动态加载的接口。

namespace MyCompany.MyProduct.MyComponent
{
    public abstract class MyAbstractObject : IMyObjectInterface
    {
        public abstract void MyObjectMethod();
    }

    public class MyObject : MyAbstractObject
    {
        public override void MyObjectMethod() { }
    }

    public abstract class MyAbstractContent<T> : IMyContentInterface<T>
        where T : MyAbstractObject
    {
        public Type ObjectType
        {
            get
            {
                return typeof(T);
            }
        }

        public abstract void MyContentMethod();
    }

    public class MyContent : MyAbstractContent<MyObject>
    {
        public override void MyContentMethod() { }
    }
}

程序集 MyCompany.MyProduct

您的程序在此程序集中组成，这是我从托管扩展性中提取的术语框架。假定接口更有可能保留 与产品开发期间的实现兼容。这种设计试图支持内聚而非耦合（一对经常被误解的词），但是实际的实施在能否成功实现这一目标方面往往存在很大差异。

namespace MyCompany.MyProduct
{
    using MyCompany.MyProduct.MyComponent;
    using System.Reflection;
    using System.Security.Policy;

    public class ComponentHost
    {
        public void LoadComponents()
        {
            Assembly implementation = LoadImplementationAssembly();

            /* The implementation assembly path might be loaded from an XML or
             * similar configuration file
             */
            Type objectType = implementation.GetType("MyCompany.MyProduct.MyComponent.MyObject");
            Type contentType = implementation.GetType("MyCompany.MyProduct.MyComponent.MyContent");

            /* THIS assembly only works with IMyContentInterface (not generic),
             * but inside the implementation assembly, you can use the generic
             * type since you can reference generic type parameter in the source.
             */
            IMyContentInterface content = (IMyContentInterface)Activator.CreateInstance(contentType);
        }

        private Assembly LoadImplementationAssembly()
        {
            /* The implementation assembly path might be loaded from an XML or
             * similar configuration file
             */
            string assemblyPath = "MyCompany.MyProduct.MyComponent.Implementation.dll";
            return Assembly.LoadFile(assemblyPath);
        }
    }
}

最后说明：

托管可扩展性框架是作为您正在处理的问题的通用解决方案而构建的。在使用它一段时间后，我自信地说它具有以下良好的特性：

• 相对较短的学习曲线。
• 结果代码非常干净。
• 运行成本低（程序集小，性能相当好）。

如果它满足以下一个或多个条件的任意组合，我会很容易地推荐它作为开发新应用程序的人的严肃可行的选择：

• 应用程序被划分为组件（几乎所有重要的应用程序都是如此）。
• 未来应用程序需要灵活或可扩展（就像任何长期项目一样）。
• 应用程序需要从未知程序集中动态加载实现。

Answer 4

这是一种动态加载接口的方法。这假设您有某种方式获取您尝试从中加载它的程序集以及类型名称的字符串。

就我而言，我使用了 Xml 文件。您可以使用任何方法，我不会展示这些方法，因为它可能会根据您的实现而改变。

ISomeInterface myInterface = this.GetComponent<ISomeInterface>("SomeImplementation");


public T GetComponent<T>(string componentName)
{
    // A method to dymanicly load a .dll, not shown in this example
    Assembly assembly = this.GetComponentAssembly(componentName);

    // A method to get a string assembly type, in this case from another source
    string assemblyType = this.GetAssemblyType(componentName);

    T component = (T)assembly.CreateInstance(assemblyType);

    return component;
}