在基本抽象类中使用派生类型

时间:2013-07-02 17:45:57

标签: c# inheritance type-parameter

好的,我有一些派生自基类的不同类。 这个基类是一个包含commom方法的抽象。

其中一个方法是Copy方法,它应该出现在所有派生类中,所以,我把它放在基类中。 但是,我希望它返回derived type而不是基础也不是对象。

我得到的解决方案是使用类型参数:

abstract class CopyableClass<T>
{
    public abstract T Copy();
}

class DerivedClass : CopyableClass<DerivedClass>
{
    public override DerivedClass Copy()
    {
        //do what is needed for copy and return a new DerivedClass
    }
}

所以,这里的主要目的是

  

删除基类中的type参数,仍然使方法返回相应的派生类型。


一种解决方法。

到目前为止,我能做的最好的事情是以下评论之一,但它仍然使用通用参数

abstract class BaseClass
{
    //base methods not related to deriving type
}

interface ICopyable<T>
{
     T Copy();
}

class DerivedClass : BaseClass, ICopyable<DerivedClass>
{
    public DerivedClass Copy()
    {
        //do what is needed for copy and return a new DerivedClass
    }
}

4 个答案:

答案 0 :(得分:5)

你不能真的。基类不可能知道所有未来的实现。您将不得不求助于通用抽象类(与您一样)类型或通用Copy方法。

public abstract class CopyableClass
{
    public abstract T Copy<T>() where T : CopyableClass;
}

public class DerivedClass : CopyableClass
{
    public override T Copy<T>()
    {
        if(typeof(T) != typeof(DerivedClass))
            throw new ArgumentException();

        // return your copy
    }
}

或者,如果要在基类中概括类型检查:

public abstract class CopyableClass
{
    public T Copy<T>() where T : CopyableClass
    {
        if(GetType() != typeof(T))
            throw new ArgumentException();

        return (T) Copy();
    }

    protected abstract CopyableClass Copy();
}

public class DerivedClass : CopyableClass
{
    protected override CopyableClass Copy()
    {
        return // Your copy;
    }
}

请注意,第二种方法将很多信任放入派生类的实现中,因为它会盲目地转换抽象方法的返回值。编译器将允许您在派生类型中返回另一个类型,实现CopyableClass,但它将是运行时错误。如果您对所有派生实现具有绝对控制权(即您的抽象类也有内部构造函数),则这不是问题。

答案 1 :(得分:0)

您实际上希望在基类中实现副本并让它返回T。这将使您使用类型参数调用它并返回该类型。

public static T Copy<T>() where T : CopyableClass
{
    T retVal = new T();
    // do whatever copying is required
    return retVal;
}

要打电话给你;

DerivedClass d = Copy<DerivedClass>();

实际执行副本的代码可能需要更多的工作来制作通用,但是值得付出努力,因为您将拥有适用于任何派生类型的Copy()的单个实现。我不知道该方法中有什么逻辑,所以我只是把事情搞砸了。另外,我建议一般检查泛型。对于像这样的事情,它们通常是最好的选择。如果你的实现需要对基类是唯一的'保持相同的方法定义但是使它抽象,然后在基类中重写它。

答案 2 :(得分:0)

这将允许您将此基类置于派生类型并返回它。

public abstract class BaseClass<TDerived> : where TDerived: BaseClass<TDerived>
{
   public TDerived DoSomethingCommon(string param)
   {
      var derivedType = (TElement)this;
      //do something.
      return derivedType;
   }
}

答案 3 :(得分:0)

这个解决方案涉及中产阶级,但我认为它更符合您的要求。至少你可以获得隔离复制代码的可能好处

    public abstract class BaseClass
    {
    }

    public abstract class CopyableClass<T> : BaseClass
        where T: BaseClass, new()
    {
        public T Copy()
        {
            var copy = new T(); // Creating a new instance as proof of concept

            return copy;
        }
    }

    public class DerivedClass : CopyableClass<DerivedClass>
    {
    }