C# 实例化类的泛型字段

有没有办法让类中的泛型字段专门化为构造函数中的特定类型

例如：

class concreteClass1
{
    private int a;
    public concreteClass1( int a)
    {
        this.a = a;
    }
}

class concreteClass2
{
    string b;
    public concreteClass2(string b)
    {
        this.b = b;
    }
}

class A<T>
{
    private T field;
    public A(int x)
    {
        field = new concreteClass1(x); //error here CS0029
    }

    public A(string y)
    {
        field = new concreteClass2(y); //error here CS0029
    }
}

class1
{
私人INTA；
公共混凝土类别1（INTA）
{
这个a=a；
}
}
类别2
{
b串；
公共类2（字符串b）
{
这个.b=b；
}
}
甲级
{
私人T场；
公共A（int x）
{
field=new concreteClass1（x）；//此处错误CS0029
}
公共A（字符串y）
{
field=new concreteClass2（y）；//此处错误CS0029
}
}

---

因此

T

可以是

concreteClass1

或

concreteClass1

，它们各自的CTOR将具有不同的签名。

由于必须转换类型，这有点棘手。也许这对你有用

class Program
{
    static void Main(string[] args)
    {
        var myImplementation = new Implementation<int>(4);
        var myImplementation2 = new Implementation<string>("Hello World");

        Console.WriteLine(myImplementation.myConcreteField); // outputs 4!
        Console.WriteLine(myImplementation2.myConcreteField); // outputs Hello World
    }
}

abstract class MyAbstract<T>
{
    public T MySomething;
    public MyAbstract(T something)
    {
        MySomething = something;
    }
}

class ConcreteA<T> : MyAbstract<T>
{
    public ConcreteA(int something) : base((T)Convert.ChangeType(something, typeof(T)))
    {
    }
}

class ConcreteB<T> : MyAbstract<T>
{
    public ConcreteB(string something) : base((T)Convert.ChangeType(something, typeof(T)))
    {
    }
}

class Implementation<T>
{
    public MyAbstract<T> myConcreteField;

    public Implementation(T a)
    {
        myConcreteField = new ConcreteA<T>(4);
    }

    void DoSomething()
    {
        Console.Write(myConcreteField.MySomething.ToString());
    }
}

类程序
{
静态void Main（字符串[]参数）
{
var myImplementation=新实现（4）；
var myImplementation2=新实现（“Hello World”）；
Console.WriteLine（myImplementation.myConcreteField）；//输出4！
Console.WriteLine（myImplementation2.myConcreteField）；//输出Hello World
}
}
抽象类MyAbstract
{
公共事务；
公共MyAbstract（T something）
{
我的某物=某物；
}
}
类：MyAbstract
{
public-ConcreteA（int-something）：base（（T）Convert.ChangeType（something，typeof（T）））
{
}
}
B类：MyAbstract
{
public-ConcreteB（string-something）：base（（T）Convert.ChangeType（something，typeof（T）））
{
}
}
类实现
{
公共领域；
公共实施（TA）
{
myConcreteField=新混凝土A（4）；
}
无效剂量测定法（）
{
Write（myConcreteField.MySomething.ToString（））；
}
}

我会重构它以使用依赖注入。这样类就不包含创建它所依赖的其他类的代码，比如

myConcreteField=newconcretea（4）。依赖注入用于防止代码陷入这样的困境

（您的示例非常抽象，这使得它有点困难。如果您使用诸如“Concrete”和“Implementation”之类的类名，则会使答案更难阅读，因为我们使用这些词来描述概念。）

相反，无论
具体的东西是什么，都要声明一个接口，比如

public interface ISomethingThatTheOtherClassNeeds<T>
{
    public int MySomething {get;set;}
}

public class SomethingThatTheOtherClassNeeds : ISomethingThatTheOtherClassNeeds<string>
{
    public int MySomething {get;set;}
}

不同之处在于，它不是负责创建该类，而是传递给构造函数中的
实现<代码>实现
甚至不知道类是什么-它只知道它与接口匹配

如果其他类又依赖于更多的类，那么这一点尤其有用。如果您通过在类中调用
new
来创建它们，那么该类必须知道如何创建这些类

然后使用依赖注入容器（如Windsor、Unity、Autofac等）将其连接起来。这在控制台应用程序中并不常见，但我猜这更像是实验性的而不是真实的？这似乎是一个错误。你想做什么需要你这么做？泛型代码应该是泛型的。泛型代码的全部要点是，无论使用何种特定类型，它都可以工作。事实上，您的代码没有，而且实际上只在使用一种类型时才起作用，这意味着它实际上不是泛型的，因此您不应该使用泛型。@kuhaku听起来像
Electric
和
Fuel
应该有一个公共接口或基类。不确定你在做什么，这要求它甚至不仅仅是一个简单的枚举。@kuhaku那么你的oo通常是有缺陷的。这比使用
object
而不是泛型类型参数更好吗？如果您没有将该类用作泛型类。。。不要将其设置为泛型。@Luaan well myConcreteField已转换为正确的类型。除此之外，我认为没有理由。
class Implementation<T>
{
    private readonly ISomethingThatTheOtherClassNeeds<T> _something;

    public Implementation(ISomethingThatTheOtherClassNeeds<T> something)
    {
        _something = something;
    }

    void DoSomething()
    {
        Console.Write(_something.MySomething.ToString());
    }
}