将类型变量限制为特定类或子类[关闭]

Question

我正在使用 C# 并希望在我的类中存储一个类型，但我希望该类型属于某个类或其子类。

这可能是代码的样子：

public class Factory
{

    public Type typeToInstantiate where Type: ABaseType;

    public Factory(Type instantiateThis where Type : ABaseType)
    {
        this.typeToInstantiate = instantiateThis;
    }

    public void DoTheThing()
    {
        var newObj = (ABaseType)Activator.CreateInstance(typeToInstantiate);
        newObj.PrintSomethingToConsole();
    }
}


public abstract class ABaseType
{
    public abstract void PrintSomethingToConsole();
}

public abstract class ASubType : ABaseType
{
    public override void PrintSomethingToConsole()
    {
        System.Console.WriteLine("Something");
    }
}

public abstract class AnotherSubType : ABaseType
{
    public override void PrintSomethingToConsole()
    {
        System.Console.WriteLine("Something else");
    }
}

public static void Main(string[] args)
{
    List<Factory> factories = new List<Factory>();
    factories.Add(new Factory(typeof(AnotherSubType)));
    factories.Add(new Factory(typeof(ASubType)));

    foreach (var factory in factories) factory.PrintSomethingToConsole();
}

我要解决的问题（如果有人有更好的主意）：我正在创建一种工厂，它将实例化一些指定类型的对象。所以，当这个工厂被创建时，它将被创建一个它应该实例化的类型。但是，这个工厂有一个特定的目的，所以它应该只实例化特定类（或该类的子类）的对象。

Answer 1

你是在问这样的事情吗：

class C<T> where T: SomeBaseClass
{
}

Answer 2

如果您需要在运行时进行检查，您可以在逻辑中使用Type'sIsAssignableFrom。例如

public class MyFactory
{
    Type baseType = typeof(MyBaseType);
    IDictionary<string, Type> typeMap = new Dictionary<string, Type>() {}
    public void RegisterType(string typeName, Type type) 
    {
        if (!(type == baseType || baseType.IsAssignableFrom(type)) throw new ArgumentException(nameof(type));
        typeMap.Add(typeName, type);    
    }
}

有关更详细的示例，请在此处查看我的代码：https://stackoverflow.com/a/53121973/361842

Answer 3

给定以下类：

public abstract class ABaseType
{
    public abstract void PrintSomethingToConsole();
}

public class ASubType : ABaseType
{
    public override void PrintSomethingToConsole()
    {
        System.Console.WriteLine("Something");
    }
}

public class AnotherSubType : ABaseType
{
    public override void PrintSomethingToConsole()
    {
        System.Console.WriteLine("Something else");
    }
}

（快速说明：AnotherSubType 和 ASubType 类不能是抽象的，如果你想创建它们的实例）。

你的工厂可以这样重构：

public class Factory 
{
    private readonly List<ABaseType> _instances;

    public Factory()
    {
        _instances = new List<ABaseType>();
    }

    public void Register<T>()  where T : ABaseType, new()
    {
        // creates a new instance of the object
        // As an alternative, save the type and create a new instance in DoTheThing()
        var instance = new T();
        _instances.Add(instance);
    }

    public void DoTheThing()
    {
        _instances.ForEach(x => x.PrintSomethingToConsole());
    }
}

使用代码：

var factory = new Factory();
factory.Register<AnotherSubType>();
factory.Register<ASubType>();

factory.DoTheThing();

输出：

其他的

某事

Answer 4

我理解您的要求如下：

1. 您需要一个可以包含其他类型的类，仅限于 BaseType 的子类，即类型安全。
2. 此类的不同实例必须能够存储在同一类型的变量中。

您可以使用协方差和类型约束来做到这一点。

声明协变接口：

public interface IMyFactory<out T>
{
    T Resolve();
}

在你的课堂上实现它：

public class MyFactory<T> : IMyFactory<T> where T :BaseType, new()
{
    public readonly Type typeToInstantiate;

    public MyFactory()
    {
        typeToInstantiate = typeof(T);
    }

    public T Resolve()
    {
        return new T();
    }
}

然后称呼它：

public class Program
{
    public static void Main()
    {
        IMyFactory<BaseType> factory;
        {
            factory = new MyFactory<BaseType>();
            var instance = factory.Resolve();
            Console.WriteLine(instance.GetType().FullName);
        }
        {
            factory = new MyFactory<DerivedType>() as IMyFactory<BaseType>;
            var instance = factory.Resolve();
            Console.WriteLine(instance.GetType().FullName);
        }

    }
}

注意这里只声明了一个变量，但它可以包含任一类型的工厂，并且每个工厂将在运行时解析为正确的类型，如输出所示。

输出：

Example.BaseType
Example.DerivedType

这是上面的link to a DotNetFiddle。