C# 从泛型超类定义获取正确的子类方法

如何在多个子类中实现在超类中定义的泛型方法？ 我需要根据调用子类实例的类型确定正确的子类方法：

var someClassObj = new SubClass();
var = someClassObj.BuildList(v1, v2);

public abstract class SomeBase
{
    public List<T> BuildList<T>(int v1, int v2)
    {
        var results = new List<T>();

        for (int i = v1; i < v2; i++)
        {
            results.Add(AddItem<T>());
        }
        return results;
    }

    protected abstract T AddItem<T>();
}

public class SubClass : SomeBase
{


    protected override BusinessThing AddItem<T>()
    {
        var entity = new BusinessThing();
        entity.Name1 = "1";
        entity.Name2 = "2";
        entity.Name3 = "3";
        return entity;
    }
}

public class BusinessThing
{
    public string Name1 { get; set; }
    public string Name2 { get; set; }
    public string Name3 { get; set; }
}

var someClassObj=新的子类（）；
var=someClassObj.BuildList（v1，v2）；
公共抽象类库
{
公共列表构建列表（intv1，intv2）
{
var results=新列表（）；
对于（int i=v1；i

---

上述未生成：重写方法“T SomeBase.AddItem（）”时无法更改返回类型。

您将使基类成为泛型而不是其方法：

public abstract class SomeBase<T>
{
    public List<T> BuildList(int v1, int v2)
    {
        var results = new List<T>();

        for (int i = v1; i < v2; i++)
        {
            results.Add(AddItem());
        }
        return results;
    }

    protected abstract T AddItem();
}

public class SubClass : SomeBase<BusinessThing>
{
    protected override BusinessThing AddItem()
    {
        var entity = new BusinessThing();
        entity.Name1 = "1";
        entity.Name2 = "2";
        entity.Name3 = "3";
        return entity;
    }
}

公共抽象类SomeBase
{
公共列表构建列表（intv1，intv2）
{
var results=新列表（）；
对于（int i=v1；i

您可以将基类设置为泛型，而不是其方法：

public abstract class SomeBase<T>
{
    public List<T> BuildList(int v1, int v2)
    {
        var results = new List<T>();

        for (int i = v1; i < v2; i++)
        {
            results.Add(AddItem());
        }
        return results;
    }

    protected abstract T AddItem();
}

public class SubClass : SomeBase<BusinessThing>
{
    protected override BusinessThing AddItem()
    {
        var entity = new BusinessThing();
        entity.Name1 = "1";
        entity.Name2 = "2";
        entity.Name3 = "3";
        return entity;
    }
}

公共抽象类SomeBase
{
公共列表构建列表（intv1，intv2）
{
var results=新列表（）；
对于（int i=v1；i

如果您不想像Daniel建议的那样拥有泛型类，您还可以告诉编译器t在使用

where

子句限制泛型类型：

public abstract class SomeBase
{
    public List<T> BuildList<T>(int v1, int v2) where T: BusinessThing
    {
        var results = new List<T>();

        for (int i = v1; i < v2; i++)
        {
            results.Add(AddItem<T>());
        }
        return results;
    }

    protected abstract T AddItem<T>() where T:BusinessThing;
}

public class SubClass : SomeBase
{
    protected override T AddItem<T>()
    {
        var entity = new BusinessThing();
        entity.Name1 = "1";
        entity.Name2 = "2";
        entity.Name3 = "3";
        return (T)entity;
    }
}

公共抽象类SomeBase
{
公共列表构建列表（intv1，intv2），其中T:BusinessThing
{
var results=新列表（）；
对于（int i=v1；i

然后按如下方式使用：

var someClassObj = new SubClass();
var list = someClassObj.BuildList<BusinessThing>(5, 7);

var someClassObj=新的子类（）；
var list=someClassObj.BuildList（5,7）；

这还允许您使用派生的ConcreteBusinessThing类，该类派生自BusinessThing，该类还应使用：

public class SubClass : SomeBase
{
    protected override T AddItem<T>()
    {
        var entity = new ConcreteBusinessThing();
        entity.Name1 = "1";
        entity.Name2 = "2";
        entity.Name3 = "3";
        return (T)(object)entity; // ugly cast but is always ok
    }
}

公共类子类：SomeBase
{
受保护的覆盖T AddItem（）
{
var entity=new-ConcreteBusinessThing（）；
entity.Name1=“1”；
entity.Name2=“2”；
entity.Name3=“3”；
return（T）（object）entity；//难看的cast，但总是ok
}
}

并称之为：

var someClassObj = new SubClass();
var list = someClassObj.BuildList<ConcreteBusinessThing>(5, 7);

var someClassObj=新的子类（）；
var list=someClassObj.BuildList（5,7）；

如果您不想像Daniel建议的那样拥有泛型类，您还可以告诉编译器t在使用

where

子句限制泛型类型：

public abstract class SomeBase
{
    public List<T> BuildList<T>(int v1, int v2) where T: BusinessThing
    {
        var results = new List<T>();

        for (int i = v1; i < v2; i++)
        {
            results.Add(AddItem<T>());
        }
        return results;
    }

    protected abstract T AddItem<T>() where T:BusinessThing;
}

public class SubClass : SomeBase
{
    protected override T AddItem<T>()
    {
        var entity = new BusinessThing();
        entity.Name1 = "1";
        entity.Name2 = "2";
        entity.Name3 = "3";
        return (T)entity;
    }
}

公共抽象类SomeBase
{
公共列表构建列表（intv1，intv2），其中T:BusinessThing
{
var results=新列表（）；
对于（int i=v1；i

然后按如下方式使用：

var someClassObj = new SubClass();
var list = someClassObj.BuildList<BusinessThing>(5, 7);

var someClassObj=新的子类（）；
var list=someClassObj.BuildList（5,7）；

这还允许您使用派生的ConcreteBusinessThing类，该类派生自BusinessThing，该类还应使用：

public class SubClass : SomeBase
{
    protected override T AddItem<T>()
    {
        var entity = new ConcreteBusinessThing();
        entity.Name1 = "1";
        entity.Name2 = "2";
        entity.Name3 = "3";
        return (T)(object)entity; // ugly cast but is always ok
    }
}

公共类子类：SomeBase
{
受保护的覆盖T AddItem（）
{
var entity=new-ConcreteBusinessThing（）；
entity.Name1=“1”；
entity.Name2=“2”；
entity.Name3=“3”；
return（T）（object）entity；//难看的cast，但总是ok
}
}

并称之为：

var someClassObj = new SubClass();
var list = someClassObj.BuildList<ConcreteBusinessThing>(5, 7);

var someClassObj=新的子类（）；
var list=someClassObj.BuildList（5,7）；

您是否尝试过ClassObj.BuildList（v1，v2）；？您是否尝试过ClassObj.BuildList（v1，v2）；？