抽象函数和数据类型 - 是否有任何优雅的方式来做到这一点？

Question

我有一个大家族的所有后代单亲。这些对象都知道如何判断它们是否已被修改，但是我还需要能够查看一个对象的新实例是否已经被修改，与我已经在内存中创建的对象相比（测试是否有其他人更新了数据库。当对象正在编辑）

结果是每个子类必须包含同样的方法：

public new bool Changed() 
{ 
    return Changed(this); 
} 

这真使我无法忍受，但我看到没有办法解决它的实际工作需要通过一个函数来完成，该函数的参数类型与它在—中的类相同，因此它不能是虚拟的。 （当然，我可以将它定义为每次都接受父对象并进行投射，但这会使得比较函数接受树中的任何对象，而不仅仅是正确的对象，并且它需要每个实例中的守卫代码，而且还有些不好。）

当然这可以工作，但我不喜欢丑陋的代码。

更新：至于Changed函数，每个对象在加载时都保留其状态的副本。

Answer 1

只要你的基类是abstract，你可以做这样的事情：

abstract class Base 
{ 
    public abstract bool Changed<T>(T obj) where T : Base; 

    public bool Changed() 
    { 
     return Changed(this); 
    } 
} 

class Subclass : Base 
{ 
    public override bool Changed<Subclass>(Subclass obj) 
    { 
     // Do stuff here 
    } 
} 

Answer 2

的基本结构：

public abstract class Base<T> where T : Base<T> 
{ 
    public T Original { get; private set; } 

    public abstract bool Changed(T o); 

    public bool Changed() 
    { 
     return this.Changed(Original); 
    } 
} 

public class DerivedA : Base<DerivedA> 
{ 
    public override bool Changed(DerivedA o) 
    { 
     throw new NotImplementedException(); 
    } 
} 

public class DerivedB : Base<DerivedB> 
{ 
    public override bool Changed(DerivedB o) 
    { 
     throw new NotImplementedException(); 
    } 
} 

虽然它有它的缺点（readiblity），也可能是在这种情况下是正确的选择，因为你的问题不是古典动物/狗/猫的意义上的类型保护，而是代码共享。

为了避免这种情况：

public class DerivedC : DerivedB 
{ 
} 
new DerivedB().Changed(new DerivedC()); // compiles 

你可以封DerivedB。

或者你可以继续疯狂（我不会低于这个水平推荐这绝对不是进一步。）：

public abstract class DerivedE<T> : Base<DerivedE<T>> where T : DerivedE<T> 
{ 
} 

public class DerivedF : DerivedE<DerivedF> 
{ 
} 

public class DerivedG : DerivedE<DerivedG> 
{ 
} 

new DerivedF().Changed(new DerivedG()); // does not compile 
new DerivedF().Changed(new DerivedF()); // does compile 

看到这个http://blogs.msdn.com/b/ericlippert/archive/2011/02/03/curiouser-and-curiouser.aspx。我从那篇文章中得到了灵感。他讨论了利弊。

编辑：整理后，根据意见

Answer 3

相同的答案MiniTech移动调整，所以他应该得到的功劳，但在这个例子中，改变SubclassA可以通过铸造全名为类查看其属性。

namespace ConsoleApplication1 
{ 

    abstract class Base 
    {  
     protected abstract bool Changed<T>(T obj) where T : Base;  
     public bool Changed()  
     {   
      return Changed(this);  
     } 

     public String PropBase { get; set; } 
    } 

    class SubclassA : Base 
    { 
     public String PropA { get; set; } 

     protected override bool Changed<SubclassA>(SubclassA obj)  
     { 
      ConsoleApplication1.SubclassA myInstance = obj as ConsoleApplication1.SubclassA; 
      // Now can see PropA 
      myInstance.PropA = "A"; 
      return true; 
     } 


    } 

    class SubclassB : Base 
    { 
     protected override bool Changed<SubclassB>(SubclassB obj) 
     { 
      // can't see prop B here 
      // obj.PropB = "B"; 
      return true; 
     } 

     public String PropB { get; set; } 
    } 


    class Program 
    { 
     static void Main(string[] args) 
     { 

      SubclassB x = new SubclassB(); 

      x.Changed(); 

      Base y = new SubclassA(); 

      y.Changed(); 
     } 
    } 
}