C# 继承需要构造函数的泛型类型的抽象类

我创建了一些类，如下所示：

abstract class TestBase<T, TThis> where TThis : TestBase<T, TThis>, new()
{
    public T Thing { get; set; }
    public static TThis CreateNew(T t)
    {
        return new TThis {Thing = t};
    }
}

abstract class MiddleClass : TestBase<string, MiddleClass>
{
    public abstract void DoSomething();
}

class RealClass : MiddleClass
{
    public override void DoSomething()
    {
        // do something
    }
}
...
var mc = RealClass.CreateNew("Hello world");
mc.DoSomething();

抽象类TestBase，其中ttthis:TestBase，new（）
{
公共T事物{get；set；}
公共静态T此CreateNew（T）
{
返回新的ttthis{Thing=t}；
}
}
抽象类中间类：TestBase
{
公共抽象无效DoSomething（）；
}
阶级：中产阶级
{
公共覆盖无效DoSomething（）
{
//做点什么
}
}
...
var mc=RealClass.CreateNew（“Hello world”）；
mc.DoSomething（）；

如您所见，使用此模式，我可以模拟静态方法

CreateNew（）

的一种继承，该方法返回调用的

TestBase

子类的类型。适用于从

TestBase

派生的具体类

问题是，在这种特殊情况下，它不会编译，因为

MiddleClass

是抽象的，因此没有无参数构造函数来满足

new（）

约束

---

除了让

中产阶级

具体化之外，你能想出一个解决办法吗？

你也可以让

中产阶级

通用化：

abstract class MiddleClass<T> : TestBase<string, T> where T : MiddleClass<T>, new()
{
    public abstract void DoSomething();
}

---

您还可以使

中产阶级
通用化：

abstract class MiddleClass<T> : TestBase<string, T> where T : MiddleClass<T>, new()
{
    public abstract void DoSomething();
}

让你的中产阶级成为普通人

    abstract class TestBase<T, TThis> where TThis : TestBase<T, TThis>, new()
    {
        public T Thing { get; set; }
        public static TThis CreateNew(T t)
        {
            return new TThis { Thing = t };
        }
    }

    abstract class MiddleClass<TThis> 
         : TestBase<string, TThis> where TThis : TestBase<string, TThis>, new()
    {
        public abstract void DoSomething();
    }

    class RealClass : MiddleClass<RealClass>
    {
        public override void DoSomething()
        {
            // do something
        }
    }

抽象类TestBase，其中ttthis:TestBase，new（）
{
公共T事物{get；set；}
公共静态T此CreateNew（T）
{
返回新的ttthis{Thing=t}；
}
}
抽象中产阶级
：TestBase，其中ttthis:TestBase，new（）
{
公共抽象无效DoSomething（）；
}
阶级：中产阶级
{
公共覆盖无效DoSomething（）
{
//做点什么
}
}
只要让你的中产阶级变得普通就行了

    abstract class TestBase<T, TThis> where TThis : TestBase<T, TThis>, new()
    {
        public T Thing { get; set; }
        public static TThis CreateNew(T t)
        {
            return new TThis { Thing = t };
        }
    }

    abstract class MiddleClass<TThis> 
         : TestBase<string, TThis> where TThis : TestBase<string, TThis>, new()
    {
        public abstract void DoSomething();
    }

    class RealClass : MiddleClass<RealClass>
    {
        public override void DoSomething()
        {
            // do something
        }
    }

抽象类TestBase，其中ttthis:TestBase，new（）
{
公共T事物{get；set；}
公共静态T此CreateNew（T）
{
返回新的ttthis{Thing=t}；
}
}
抽象中产阶级
：TestBase，其中ttthis:TestBase，new（）
{
公共抽象无效DoSomething（）；
}
阶级：中产阶级
{
公共覆盖无效DoSomething（）
{
//做点什么
}
}
谢谢！最快答案获胜。：）非常感谢。最快答案获胜。：）