C# 定义将在构造函数中使用的类型

我想将类型为

AbstractObject

的对象与我的当前类相关联

但是，这必须在构造函数中完成，因为当我定义类时，我不知道将关联哪种类型的对象（只知道这是类型

AbstractObject

）。我需要在类中构造关联的对象（因此我不能将实例作为参数）

所以它会是这样的：

public abstract class MyClass
{
    public MyClass(Type T) where T : AbstractObject
    {
        (T)Actiocator.CreateInstance(Typeof(T));
        //To do 
    }
}

但这不起作用。知道如何解决这个问题吗？

试试这个：

public abstract class MyClass<T> where T : AbstractObject, new()
{
    public MyClass(T type)
    {
        T instance = new T();
    }
}

公共抽象类MyClass，其中T:AbstractObject，new（）
{
公共MyClass（T型）
{
T实例=新的T（）；
}
}

如果在泛型约束中添加

new（）

，则可以调用类的无参数构造函数

---

创建一个接口或一个抽象类，让他们在要传递给当前类构造函数的类中实现它

public interface ITest
{

 // your interface method and properties
}

public class Child : ITest
{
 // do your stuff here
}

public abstract class MyClass
{
    public MyClass(ITest tes)
    {
    // do stuff using test
    }
}

---

也许这样的东西适合你

abstract class AbstractObject {}
class Test :  AbstractObject
{
    public Test()
    {
        Console.WriteLine("I work");
    }
}
class GenTest<T> where T: AbstractObject, new()
{
    T obj;
    public GenTest()
    {
        obj = new T();
    }
}

public static void Main()
{
    var genTestObj = new GenTest<Test>();
}

抽象类抽象对象{}
类测试：抽象对象
{
公开考试（）
{
Console.WriteLine（“我工作”）；
}
}
类GenTest，其中T:AbstractObject，new（）
{
T-obj；
公共绅士
{
obj=新的T（）；
}
}
公共静态void Main（）
{
var genTestObj=new GenTest（）；
}

根据您的用例，有几个选项

传入对象 最简单的方法是让调用者构造对象，并通过构造函数传入：

public MyClass(AbstractObject template) 
{
    // Do something with template
}

private MyClass(AbstractObject template) 
{
    // Do something with template 
}

public MyClass Create<T>() where T : AbstractObject, new()
{
    // Create a temporary object just for passing into the private ctor
    return new MyClass(new T());
}

提供静态工厂方法 扩展上述思想，如果您想控制构造函数使用的对象，可以提供一个静态方法，创建

Base

对象并将其传递给构造函数：

public MyClass(AbstractObject template) 
{
    // Do something with template
}

private MyClass(AbstractObject template) 
{
    // Do something with template 
}

public MyClass Create<T>() where T : AbstractObject, new()
{
    // Create a temporary object just for passing into the private ctor
    return new MyClass(new T());
}

还要注意，我添加了

new（）

约束，因此我可以简单地编写

newt

。如果您知道

T

将成为

AbstractObject

的派生类，这是一种引用类型，那么这是很好的。如果希望能够从值类型（如

int

）构造

MyClass

es，可以删除

new（）

约束并使用反射

使类成为泛型 如果还需要在类中存储对象，请将整个类设置为泛型：

public class MyClass<T> where T : AbstractObject, new()
{
    private T myObject;
    public MyClass()
    {
        this.myObject = new T();
        // Do other stuff   
    }
}

公共类MyClass，其中T:AbstractObject，new（）
{
私有T对象；
公共MyClass（）
{
this.myObject=new T（）；
//做其他事情
}
}

您为什么需要它？你想要达到的目标是什么？在构造函数中使用反射可能会导致问题。您不能在类上定义类型参数吗<代码>类MyClass，其中T:AbstractObject注意：这样做的缺点是您实际上必须传入一个

T

，它可能是一个临时对象，其唯一目的是推断

T

：例如

MyClass mc=new MyClass（new ConcreteObject（））C#不允许对非泛型进行约束declarations@nozzleman尝试执行此操作时在visual studio中描述的错误