基类方法是否可以返回派生类的类型？(Can a Base Class Method return the type of the derived class?)

 根据我读过的其他帖子，似乎这可能是不可能的，但我想我会发布我正在尝试做的事情，看看有没有人知道解决方案。 
 
 我正在尝试为从Telerik Open Access域模型生成的类添加“Clone（）”方法。 没问题。 我能够弄清楚如何将基类添加到生成的实体模型，以便我可以通过它们的基类识别这些类。 （ 所有实体都从基类继承 ） 
 
 我希望所有这些实体模型类都能克隆自己。 我也找到了解决方案。 （ 深层克隆对象 ） 
 
 现在我有一个基类，我想为每个从该基类派生的类添加一个Clone（）函数。 所以......看起来基类是放它的自然地方......对吗？ 
 
public abstract class DBEntityBase
{
    /// <summary>
    ///     Gets a COPY of the instance in it's current state
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    protected T Clone<T>()
    {
        return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(this));
    }
}
 
 我添加受保护的通用Clone（）方法，因为在基类级别上我们不知道我们正在克隆的Type。 Clone（）方法需要由实体模型本身来实现，以提供被克隆的特定类型。 
 
public partial class DeliverableEntity
{
    public new DeliverableEntity Clone()
    {
        return this.Clone<DeliverableEntity>();
    }
}
 
 这可以正常工作，但不能保证派生类将公开地公开一个Clone（）方法，所以我向该基类添加了一个抽象Clone（）方法，这将需要派生类实现公共Clone（）方法。 
 
public abstract class DarkRoomDBEntityBase
{
    /// <summary>
    ///     Gets a COPY of the instance in it's current state
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    protected T Clone<T>()
    {
        return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(this));
    }

    /// <summary>
    ///     Gets a deep COPY of the entity instance
    /// </summary>
    /// <returns></returns>
    public abstract DBEntityBase Clone();
}
 
 我给它一个基类本身的返回类型; 每个实现必须返回一个遵循DBEntityBase的值，当然，所有派生类都会这样做。 由于Clone（）方法正在返回派生类本身的类型，所以...似乎有意义的是，这会起作用。 
 
DeliverableEntity originalEntity = new DeliverableEntity();
DeliverableEntity clonedEntity   = originalEntity.Clone();
 
 然而，在建设时，我得到了错误。 
 
 
 
 'DeliverableEntity'没有实现继承的抽象成员'DBEntityBase.Clone（）' 
 
 
 可能是由于返回类型。 
 
 我知道我可以把Clone（）方法放在一个单独的工具类中，而不是直接在每个实体模型中实现它......这会让我绕过我的问题（并且可能会节省大量的实现代码），但是我仍然想知道为什么这不起作用。 似乎应该有办法做到这一点。 
 
 UPDATE 
 
 为了回应@ Luann的第一个回复（谢谢），我改变了“重写”...... 
 
public partial class DeliverableEntity
{
    public override DeliverableEntity Clone()
    {
        return this.Clone<DeliverableEntity>();
    }
}
 
 并且现在收到以下错误... 
 
 
 
 返回类型必须是'DBEntityBase'以匹配重写的成员'DBEntityBase.Clone（）' 
 
 
 解 
 
 感谢Flynn1179，我能够再次前进。 我想我会花一点时间来记录我在这里做了什么以备将来参考。 
 
 我没有为ORM中的每个实体模型创建一个部分类，而是实现了一个抽象方法，而是按照建议创建了一个扩展方法。 
 
namespace DAL
{
    public partial class DeliverableEntity : DBEntityBase
    {
         // ... Code generated from ORM 
    }

    public partial class DeliverableItemEntity : DBEntityBase
    {
         // ... Code generated from ORM 
    }

    public partial class DeliverableItemAttrEntity : DBEntityBase
    {
         // ... Code generated from ORM 
    }
}

namespace DAL
{
    public static class EntityExtensionMethods
    {
        public static T Clone<T>(this T entity) where T: DBEntityBase
        {
            return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(entity));
        }
    }
}
 
 有些事情要注意... 
 
 
 
 将这个类放置在与实体模型相同的名称空间中。 如果它位于不同的名称空间中，则需要添加该名称空间才能访问该方法。 
 
 
 我将泛型类型的约束定义为仅继承DBEntityBase类的所有类。 由于我让所有的实体模型类都从这个基类派生出来，我知道它们都会公开这个方法，但是任何不从这个类派生的类都不具备这个能力。 
 
 
 扩展方法和包含它的类必须是静态的 
 
 
 现在最酷的部分是所有的实体都可以访问该功能...... 
 
    // Create the original instances of the entities    
    DeliverableEntity origDeliverable       = new DeliverableEntity();
    DeliverableItemEntity origItem          = new DeliverableItemEntity();
    DeliverableItemAttrEntity origItemAttr  = new DeliverableItemAttrEntity();

    // now here's the magic 

    DeliverableEntity cloneDeliverable      = origDeliverable.Clone();
    DeliverableItemEntity cloneItem         = origItem.Clone();
    DeliverableItemAttrEntity cloneItemAttr = origItemAttr.Clone();
 
 我喜欢这个解决方案，因为它具有基类的简单性，其中实现在单个位置定义（而我正在寻找在每个派生类中分别实现抽象方法），另外还因为它与DBEntityBase类相关联，并且在相同命名空间，它成为基类定义的“合约”的一部分，这意味着我可以指望每当我有从DBEntityBase派生的类时它就可用。 

Based on the other posts I have read, it seems that this may not be possible, but I thought I would post what I am trying to do and see if anyone knows of a solution. 
 
I am trying to add a "Clone()" method to classes generated from a Telerik Open Access domain model. No problem. I was able to figure out how to add a base class to the generated entity models so that I could identify those classes by their base class. (All entities inherit from a base class)
 
I want ALL these entity model classes to be able to Clone themselves. I have found a solution for that as well. (Deep Cloning Objects)
 
Now I have a base class and I want to add a Clone() function to every class that derives from that base class. So ... it seems that the base class is the natural place to put it ... right? 
 
public abstract class DBEntityBase
{
    /// <summary>
    ///     Gets a COPY of the instance in it's current state
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    protected T Clone<T>()
    {
        return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(this));
    }
}
 
I add the protected generic Clone() method because at the base class level we don't know the Type we are cloning. The Clone() method needs to be implemented by the entity model itself in order to provide the specific type being cloned. 
 
public partial class DeliverableEntity
{
    public new DeliverableEntity Clone()
    {
        return this.Clone<DeliverableEntity>();
    }
}
 
This works fine, but does not guarantee that derived classes will publicly expose a Clone() method, so I added an abstract Clone() method to the base which will require the derived class to implement a public Clone() method.
 
public abstract class DarkRoomDBEntityBase
{
    /// <summary>
    ///     Gets a COPY of the instance in it's current state
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    protected T Clone<T>()
    {
        return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(this));
    }

    /// <summary>
    ///     Gets a deep COPY of the entity instance
    /// </summary>
    /// <returns></returns>
    public abstract DBEntityBase Clone();
}
 
I give it a return type of the base class itself; every implementation MUST return a value which adheres to the DBEntityBase, which of course, all derived classes do. Since the Clone() method is returning a type of the derived class itself then ... it seems to make sense that this would work.
 
DeliverableEntity originalEntity = new DeliverableEntity();
DeliverableEntity clonedEntity   = originalEntity.Clone();
 
When building, however, I get the error ..
 
 
 
'DeliverableEntity' does not implement inherited abstract member 'DBEntityBase.Clone()'
 
 
Presumably due to the return type. 
 
I know that I COULD just put the Clone() method in a separate utility class and not implement it directly in each entity model ... that would get me around my problem (and probably save a lot of implementation code), but I am still left wondering why this won't work. It seems like there should be a way to do this.
 
UPDATE
 
In response to @Luann's first reply (thank you) I made the change to "override" ...
 
public partial class DeliverableEntity
{
    public override DeliverableEntity Clone()
    {
        return this.Clone<DeliverableEntity>();
    }
}
 
and am now receiving the following error ... 
 
 
 
return type must be 'DBEntityBase' to match overridden member 'DBEntityBase.Clone()'
 
 
SOLUTION 
 
Thanks to Flynn1179 I was able to move forward again. I thought I would take a moment to document what I did here for future reference ..
 
Instead of creating a partial class for each entity model in the ORM, implementing an abstract method, I created a single extension method as suggested.
 
namespace DAL
{
    public partial class DeliverableEntity : DBEntityBase
    {
         // ... Code generated from ORM 
    }

    public partial class DeliverableItemEntity : DBEntityBase
    {
         // ... Code generated from ORM 
    }

    public partial class DeliverableItemAttrEntity : DBEntityBase
    {
         // ... Code generated from ORM 
    }
}

namespace DAL
{
    public static class EntityExtensionMethods
    {
        public static T Clone<T>(this T entity) where T: DBEntityBase
        {
            return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(entity));
        }
    }
}
 
Some things to note ... 
 
 
 
Put this class in the same Namespace as the entity models. If it's in a different namespace then you will need to add that namespace in order to have access to the method.
 
 
I defined the constraint on the generic type to only and all classes which inherit the DBEntityBase class. Since I made all my entity model classes derive from this base class I know that all of them will will expose this method but also that any class which does NOT derive from this class will NOT have this capability.
 
 
The extension method and the class that contains it must be static
 
 
Now the cool part is that ALL the Entities have access to the function ...
 
    // Create the original instances of the entities    
    DeliverableEntity origDeliverable       = new DeliverableEntity();
    DeliverableItemEntity origItem          = new DeliverableItemEntity();
    DeliverableItemAttrEntity origItemAttr  = new DeliverableItemAttrEntity();

    // now here's the magic 

    DeliverableEntity cloneDeliverable      = origDeliverable.Clone();
    DeliverableItemEntity cloneItem         = origItem.Clone();
    DeliverableItemAttrEntity cloneItemAttr = origItemAttr.Clone();
 
I love this solution as it's has the simplicity of a base class where the implementation is defined in a single location (whereas I was looking at implementing an abstract method individually in each derived class) plus since it's associated with the DBEntityBase class and in the same namespace, it becomes part of the "contract' defined by the base class which means I can count on it being available whenever I have a class derived from DBEntityBase.

原文：https://stackoverflow.com/questions/32122632