C# 如何从静态泛型属性返回子类型

我想要一个基类：

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

类别1：

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'
}

公共类主
{
var a=Base.Instance.Func1（）；//返回'class1'
var b=Base.Instance.Func1（）；//返回'class2'
}

---

请帮我做这件事。

这不是动态的，而是多态的。在这种情况下，可以通过泛型实现。剩下的唯一问题是调用构造函数，当您在

上设置类型约束时，调用构造函数就成为可能

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();
       } 
   }
}

公共类基，其中T:new（）
{
公共静态T实例
{
得到
{
//执行一些操作以从自身返回inherit类的新实例
返回新的T（）；
} 
}
}

然后：

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

public类Class1:Base{…}
公共类Class2:基{…}

---

但请注意，可以通过虚拟+覆盖方法或接口实现更简单的解决方案

这不是动态的，而是多态的。在这种情况下，可以通过泛型实现。剩下的唯一问题是调用构造函数，当您在

上设置类型约束时，调用构造函数就成为可能

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();
       } 
   }
}

公共类基，其中T:new（）
{
公共静态T实例
{
得到
{
//执行一些操作以从自身返回inherit类的新实例
返回新的T（）；
} 
}
}

然后：

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

public类Class1:Base{…}
公共类Class2:基{…}

---

但请注意，可以通过虚拟+覆盖方法或接口实现更简单的解决方案

这不是动态的，而是多态的。在这种情况下，可以通过泛型实现。剩下的唯一问题是调用构造函数，当您在

上设置类型约束时，调用构造函数就成为可能

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();
       } 
   }
}

公共类基，其中T:new（）
{
公共静态T实例
{
得到
{
//执行一些操作以从自身返回inherit类的新实例
返回新的T（）；
} 
}
}

然后：

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

public类Class1:Base{…}
公共类Class2:基{…}

---

但请注意，可以通过虚拟+覆盖方法或接口实现更简单的解决方案

这不是动态的，而是多态的。在这种情况下，可以通过泛型实现。剩下的唯一问题是调用构造函数，当您在

上设置类型约束时，调用构造函数就成为可能

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();
       } 
   }
}

公共类基，其中T:new（）
{
公共静态T实例
{
得到
{
//执行一些操作以从自身返回inherit类的新实例
返回新的T（）；
} 
}
}

然后：

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

public类Class1:Base{…}
公共类Class2:基{…}

---

但请注意，可以通过虚拟+覆盖方法或接口实现更简单的解决方案

具有更严格类型限制的备选建议：

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"; }
    }
}

名称空间My.Test
{
班级计划
{
静态void Main（字符串[]参数）
{
Console.WriteLine（Base.Instance.Func1（））；
Console.WriteLine（Base.Instance.Func1（））；
}
}
公共抽象类基
{
公共抽象字符串Func1（）；
}
公共密封类基，其中T:Base，new（）
{
公共静态T实例
{
获取{返回新的T（）；}
}
}
公共类1：基本类
{
公共重写字符串Func1（）{return“class 1”；}
}
公共类2：基本类
{
公共重写字符串Func1（）{return“class 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"; }
    }
}

名称空间My.Test
{
班级计划
{
静态void Main（字符串[]参数）
{
Console.WriteLine（Base.Instance.Func1（））；
Console.WriteLine（Base.Instance.Func1（））；
}
}
公共抽象类基
{
公共抽象字符串Func1（）；
}
公共密封类基，其中T:Base，new（）
{
公共静态T实例
{
获取{返回新的T（）；}
}
}
公共类1：基本类
{
公共重写字符串Func1（）{return“class 1”；}
}
公共类2：基本类
{
公共重写字符串Func1（）{return“class 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"; }
    }
}

名称空间My.Test
{
班级计划
{
静态void Main（字符串[]参数）
{
Console.WriteLine（Base.Instance.Func1（））；
Console.WriteLine（Base.Instance.Func1（））；
}
}
公共抽象类基
{
公共抽象字符串Func1（）；
}
公共密封类基，其中T:Base，new（）
{
公共静态T实例
{
获取{返回新的T（）；}
}
}
公共类1：基本类
{
公共重写字符串Func1（）{return“class 1”；}
}
公共类2：基本类
{
公共重写字符串Func1（）{return“class 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"; }
    }
}

名称空间My.Test
{
班级计划
{
静态void Main（字符串[]参数）
{
Console.WriteLine（Base.Instance.Func1（））；
Console.WriteLine（Base.Instance.Func1（））；
}
}
公共抽象类基
{
公共抽象字符串Func1（）；
}
公共密封类基，其中T:Base，new（）
{
公共静态T实例
{
获取{返回新的T（）；}
}
}
公共类1：基本类
{
公共重写字符串Func1（）{return“class 1”；}
}
公共类2：基本类
{
公共重写字符串Func1（）{return“class 2”；}
}
}

A

GetInstance（）