抽象函數和數據類型 - 是否有任何優雅的方式來做到這一點？

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(); 
     } 
    } 
}