C#泛型方法-对类型调用基类构造函数

我有一个叫做CAR的物体，声明如下：

public class Car{
   public int NumberOfWheels;
}  

使用另一个类，我可以检索它的三个子类。
详情如下:

public TruckA getCarA(int param){
   return new TruckA () {NumberOfWheels = param} 
}
public TruckB getCarB(int param){
   return new TruckB () {NumberOfWheels = param} 
}
public TruckC getCarC(int param){
   return new TruckC () {NumberOfWheels = param} 
}

如何使用泛型书写？
（我知道这太简单了，我需要一个更复杂的例子）

我想创建一个方法，创建一个新的（T），输入参数并返回它

差不多

public TruckC getCarC(int param){
   return getTruck<TruckC>(param)
}

public-TruckC-getCarC（int-param）{
返回getTruck（参数）
}

仅此：
1.卡车/B/C没有构造函数。
2.这辆车没有构造师。使用{}初始化。
3.该方法应该只接收从Car派生的类，以便可以使用其初始化（{}）

（与java泛型中的“扩展”相当的东西）
可能吗

谢谢

private static T GetTruck（int参数），其中T:Car，new（）
{
返回新的T（）{NumberOfWheels=param}；
}

试试这个：

public T getCarC<T>(int param) where T : Car, new()
        {
            T truck=new T();
            truck.NumberOfWheels = param;

            return track;
        }

public class BaseClass<T>
{...}
public class SubClass : BaseClass<int>
{...}

public class SubClass<T> : BaseClass<T> 
{...}

public class BaseClass<T>  where T : ISomeInterface 
{...}
public class SubClass<T> : BaseClass<T> where T : ISomeInterface
{...}

public class BaseClass<T>  where T : new()
{   
   public T SomeMethod()
   {
      return new T();
   }
}
public class SubClass<T> : BaseClass<T> where T : new() 
{...}

public T getCarC（int参数），其中T:Car，new（）
{
T卡车=新的T（）；
truck.NumberOfWheels=参数；
返回轨道；
}

泛型是C#2.0最强大的功能。泛型允许您定义类型安全的数据结构，而无需提交到实际的数据类型

从泛型基类派生时，必须提供类型参数而不是基类的泛型类型参数：

public T getCarC<T>(int param) where T : Car, new()
        {
            T truck=new T();
            truck.NumberOfWheels = param;

            return track;
        }

public class BaseClass<T>
{...}
public class SubClass : BaseClass<int>
{...}

public class SubClass<T> : BaseClass<T> 
{...}

public class BaseClass<T>  where T : ISomeInterface 
{...}
public class SubClass<T> : BaseClass<T> where T : ISomeInterface
{...}

public class BaseClass<T>  where T : new()
{   
   public T SomeMethod()
   {
      return new T();
   }
}
public class SubClass<T> : BaseClass<T> where T : new() 
{...}

公共类基类
{...}
公共类子类：基类
{...}

如果子类是泛型的，而不是具体的类型参数，则可以使用子类泛型类型参数作为泛型基类的指定类型：

public T getCarC<T>(int param) where T : Car, new()
        {
            T truck=new T();
            truck.NumberOfWheels = param;

            return track;
        }

public class BaseClass<T>
{...}
public class SubClass : BaseClass<int>
{...}

public class SubClass<T> : BaseClass<T> 
{...}

public class BaseClass<T>  where T : ISomeInterface 
{...}
public class SubClass<T> : BaseClass<T> where T : ISomeInterface
{...}

public class BaseClass<T>  where T : new()
{   
   public T SomeMethod()
   {
      return new T();
   }
}
public class SubClass<T> : BaseClass<T> where T : new() 
{...}

公共类子类：基类
{...}

使用子类泛型类型参数时，必须在子类级别重复基类级别规定的任何约束。例如，派生约束：

public T getCarC<T>(int param) where T : Car, new()
        {
            T truck=new T();
            truck.NumberOfWheels = param;

            return track;
        }

public class BaseClass<T>
{...}
public class SubClass : BaseClass<int>
{...}

public class SubClass<T> : BaseClass<T> 
{...}

public class BaseClass<T>  where T : ISomeInterface 
{...}
public class SubClass<T> : BaseClass<T> where T : ISomeInterface
{...}

public class BaseClass<T>  where T : new()
{   
   public T SomeMethod()
   {
      return new T();
   }
}
public class SubClass<T> : BaseClass<T> where T : new() 
{...}

公共类基类，其中T:i接口
{...}
公共类子类：基类，其中T:ISomeInterface
{...}

或构造函数约束：

public T getCarC<T>(int param) where T : Car, new()
        {
            T truck=new T();
            truck.NumberOfWheels = param;

            return track;
        }

public class BaseClass<T>
{...}
public class SubClass : BaseClass<int>
{...}

public class SubClass<T> : BaseClass<T> 
{...}

public class BaseClass<T>  where T : ISomeInterface 
{...}
public class SubClass<T> : BaseClass<T> where T : ISomeInterface
{...}

public class BaseClass<T>  where T : new()
{   
   public T SomeMethod()
   {
      return new T();
   }
}
public class SubClass<T> : BaseClass<T> where T : new() 
{...}

公共类基类，其中T:new（）
{   
公共T方法（）
{
返回新的T（）；
}
}
公共类子类：基类，其中T:new（）
{...}

您需要使用泛型类型约束来执行此操作。这些允许您对传递的类型提出要求

它看起来像这样：

public static T GetCar<T>(int param)
    where T : Car, new() // Must inherit from Car, must have a parameterless constructor
{
    return new T() { NumberOfWheels = param };
}

public static T GetCar（int参数）
其中T:Car，new（）//必须继承自Car，必须具有无参数构造函数
{
返回新的T（）{NumberOfWheels=param}；
}

Google查找泛型类型约束。

1。卡车没有建造师。2.Car有一个构造函数（我假设不是无参数的）。

这是不可能的。@HamletHakobyan作者省略了TruckX定义，所以您不知道它是否有无参数构造函数。但显然是这样，因为他打电话来了it@deej仔细看。从OP

1。TruckA/B/C没有构造函数。

@HamletHakobyan你让我怀疑。但是如果2，那么1是不可能的。所以我假设1意味着TruckX有显式的无参数constructor@rails你试过这个吗。卡车没有建造师。2.Car有一个构造函数（公共Car（int-param））？@HamletHakobyan：解决方案有效。但是谢谢你注意到我的错误。在我的真实代码中，我使用{}进行初始化，并且成员是私有的。我在问题中更新了这个错误。