Question

我想要一个基类：

public class Base
{
   public static T Instance 
   {
       get
       {
           // do something to return new instance of inherit class from itself
       } 
   }
}

Class1：

public class Class1 : Base
{
      // method and properties here
      public string Func1()
      {
            return 'class1';
      }
}

等级2：

public class Class2 : Base
{
      // method and properties here
      public string Func1()
      {
            return 'class2';
      }
}

我想要它，以便我们可以像这样使用Class1或Class2

public class Main
{
      var a = Base<Class1>.Instance.Func1(); // return 'class1'
      var b = Base<Class2>.Instance.Func1(); // return 'class2'
}

请帮我这样做。

Answer 1

这不是动态的，而是多态的。在这种情况下用泛型实现。你唯一剩下的问题是调用构造函数，当你在<T>上放置一个Type-constraint时就可以了。

public class Base<T> where T : new()
{
   public static T Instance 
   {
       get
       {
           // do something to return new instance of inherit class from itself
           return new T();
       } 
   }
}

然后：

public class Class1 : Base<Class1> { ... }
public class Class2 : Base<Class2> { ... }

但请注意，使用虚拟+覆盖方法或界面可以实现更简单的解决方案。

Answer 2

一些更严格的类型约束的替代建议：

namespace My.Test
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Base<Class1>.Instance.Func1());
            Console.WriteLine(Base<Class2>.Instance.Func1());
        }
    }

    public abstract class Base
    {
        public abstract string Func1();
    }

    public sealed class Base<T> where T : Base, new()
    {
        public static T Instance
        {
            get { return new T(); }
        }
    }

    public class Class1 : Base
    {
        public override string Func1() { return "class 1"; }
    }

    public class Class2 : Base
    {
        public override string Func1() { return "class 2"; }
    }
}

如何从静态通用属性返回子类型

2 个答案: