18

我有以下结构： 

abstract class Base {
        public abstract List<...> Get(); //What should be the generic type?
}

class SubOne : Base {
    public override List<SubOne> Get() {

    }
}

class SubTwo : Base {
    public override List<SubTwo> Get() {

    }
}

我想创建一个抽象方法，它返回具体子类是什么类。因此，正如您从示例中看到的那样， in 中的方法SubOne应该返回List<SubOne>，而 in 中的方法SubTwo应该返回List<SubTwo>。

我在基类中声明的签名中指定什么类型？

[更新]

感谢您发布的答案。

解决方案是使抽象类通用，如下所示：

abstract class Base<T> {
        public abstract List<T> Get();
}

class SubOne : Base<SubOne> {
    public override List<SubOne> Get() {

    }
}

class SubTwo : Base<SubTwo> {
    public override List<SubTwo> Get() {

    }
}
4

5 回答 5

34

您的抽象类应该是通用的。

abstract class Base<T> {
        public abstract List<T> Get(); 
}

class SubOne : Base<SubOne> {
    public override List<SubOne> Get() {

    }
}

class SubTwo : Base<SubTwo> {
    public override List<SubTwo> Get() {
    }
}

如果您需要引用没有泛型类型参数的抽象类，请使用接口：

interface IBase {
        //common functions
}

abstract class Base<T> : IBase {
        public abstract List<T> Get(); 
}
于 2009-03-24T01:32:55.947 回答
4 
public abstract class Base<T> 
{       
    public abstract List<T> Get(); 
}

class SubOne : Base<SubOne> 
{
    public override List<SubOne> Get() { return new List<SubOne>(); }
}

class SubTwo : Base<SubTwo> 
{
    public override List<SubTwo> Get() { return new List<SubTwo>(); }
}
于 2009-03-24T01:34:28.517 回答
2

试试这个：

public abstract class Base<T> {
  public abstract List<T> Foo();
}

public class Derived : Base<Derived> {   // Any derived class will now return a List of
  public List<Derived> Foo() { ... }     //   itself.
}
于 2009-03-24T01:33:44.383 回答
1

我认为你不能让它成为特定的子类。你可以这样做：

abstract class Base<SubClass> {
        public abstract List<SubClass> Get(); 
}
class SubOne : Base<SubOne> {
    public override List<SubOne> Get() {
        throw new NotImplementedException();
    }
}
class SubTwo : Base<SubTwo> {
    public override List<SubTwo> Get() {
        throw new NotImplementedException();
    }
}
于 2009-03-24T01:33:06.180 回答
0

如果您的基类由于各种原因而无法泛型，则此方法可能很有用：

abstract class Base {
}
interface IHasGetter<T> {
  List<T> Get();
}
static class HasGetterHelper {
    public static List<T> Get<T>(this T v) where T: IHasGetter<T>  => v.Get();
}
class SubOne : Base, IHasGetter<SubOne> {
    public List<SubOne> Get() {
        throw new NotImplementedException();
    }
}
class SubTwo : Base, IHasGetter<SubTwo> {
    public List<SubTwo> Get() {
        throw new NotImplementedException();
    }
}

如果您无法将接口添加到子类，并且仍然无法将泛型添加到 Base 类型，则此方法可能很有用：（不幸的是，您无法使 GetImpl 受保护，因为不允许辅助类位于基类中)

abstract class Base {
    public abstract List<T> GetImpl<T>() where T:Base;
}
static class HasGetterHelper {
    public static List<T> Get<T>(this T v) where T: Base => v.GetImpl<T>();
}
class SubOne : Base {
    public override List<T> GetImpl<T>() {
        throw new NotImplementedException();
    }
}
class SubTwo : Base {
    public override List<T> GetImpl<T>() {
        throw new NotImplementedException();
    }
}

在这两种情况下，这都会按预期工作：

class Tester
{
   List<SubOne> TestIt() => new SubOne().Get();
}
于 2021-08-05T08:42:15.807 回答