C＃：非抽象計算屬性的多重繼承

Question

我創建了一系列包含基本屬性的接口/抽象類，我想計算屬性和多重繼承。

public abstract class /interface Modifiable 
{ 
    public DateTime ModifiedDate {get; set;} 

    public boo ModifiedToday 
    { 
    get { return DateTime.Now.AddDays(-1).CompareTo(ModifiedDate) >= 0; } 
    } 

    public bool ModifiedInLastWeek 
    { 
    get { return DateTime.Now.AddDays(-7).CompareTo(ModifiedDate) >= 0; } 
    } 
} 

public abstract class /interface Deletable 
{ 
    public DateTime DeletionDate {get; set;}  

    public bool Deleted 
    { 
    get { return DeletionDate != default(DateTime) } 
    } 
} 

然後我有一個繼承自這兩個Interfaces/Abstract類的類。

public class Something : Modifiable, Deletable 
{ 
    // 
} 

但是一個類不能從兩個抽象類繼承。所以我需要使用接口，但接口我不能有方法體。然後我必須在多個類中定義相同的確切函數，以使用接口來實現這些簡單的布爾屬性。

我也不希望有可修改的從Deletable繼承，因爲我可能想要某些東西是可修改但不可刪除的。這些具體的類不是我的問題，我只是用它們來說明我的問題。

是否有一種設計模式通過允許函數體模仿抽象類，但允許像接口那樣的多個繼承者？

Answer 1

編號C＃沒有一種機制來實現這種多重繼承。

說到接口，這是可能的，因爲當你定義多個接口時，你也需要全部實現它們。

考慮一個不同的設計，可能使用合成爲了重用您想用於多重繼承的類。

Answer 2

對不起，多重繼承在C＃中是不可能的，這對你來說是一件好事。你的選擇是：

1. 要麼到鏈基類繼承一拉MyClass的：MyBaseClass：EvenBasierClass
2. 或從多個接口繼承。並實現所有接口的所有方法。

這並不美觀，但您也可以通過檢查實例類型來控制屬性可訪問性或返回類中的值。

Answer 3

這不是多重繼承，但想到的是擴展方法。

public interface IModifiable 
{ 
    DateTime ModifiedDate {get; set;} 
} 

public static class ModifiableExtensions 
{ 
    public bool ModifiedToday(this IModifiable m) 
    { 
     return DateTime.Now.AddDays(-1).CompareTo(m.ModifiedDate) >= 0; 
    } 

    public bool ModifiedInLastWeek(this IModifiable m) 
    { 
    return DateTime.Now.AddDays(-7).CompareTo(m.ModifiedDate) >= 0; 
    } 

} 

，賦予的被烤成類的輔助方法「感覺」，但它們發生在別處聲明。藉此類：

public class MyModifiable :IModifiable 
{ 
    public ModifiedDate {get; set;} 
} 

你可以這樣做：

MyModifiable m = new MyModifiable; 

m.ModifiedDate = DateTime.Now; 

bool isToday = m.ModifiedToday(); 

Answer 4

修改的&可刪除IMO應該是接口，而不是基類。基類定義了什麼類型，而接口描述了類型的功能。

至於落實的代碼，你可以隨時使用擴展方法：

public interface IModifiable 
{ 
    public DateTime ModifiedDate {get; set;} 
} 

public interface IDeletable 
{ 
    public DateTime DeletionDate {get; set;}  
} 


public static class SomeExtentions 
{ 
    public static bool IsModifiedToday(this IModifiable modifiable) 
    { 
     return DateTime.Now.AddDays(-1).CompareTo(modifiable.ModifiedDate) >= 0; 
    } 

    public static bool IsModifiedInLastWeek(this IModifiable modifiable) 
    { 
     return DateTime.Now.AddDays(-7).CompareTo(modifiable.ModifiedDate) >= 0; 
    } 
    public static bool IsDeleted(this IDeletable deletable) 
    { 
     return deletable.DeletionDate != default(DateTime); 
    } 
} 

Answer 5

我可能會使用委派來實現這一目標。創建可修改和可刪除的接口，然後創建這些接口的實現。給這些實現的類實例Something。這裏有一個例子可刪除：

public interface Deletable 
{ 
    DateTime DeletionDate{get;set;} 
    bool Deleted{get;} 
} 

public class DeletableImpl : Deletable 
{ 
    public DateTime DeletionDate{get; set;} 
    public bool Deleted{get {return DeletionDate != default(DateTime);}} 
} 
// Do the same thing with Modifiable and ModifiableImpl 

public class Something : Deletable, Modifiable 
{ 
    private Deletable _deletable = new DeletableImpl(); 
    private Modifiable _modifiable = new ModifiableImpl(); 
    public DateTime DeletionDate 
    { 
    get{return _deletable.DeletionDate;} 
    set{_deletable.DeletionDate = value;} 
    } 
    public bool Deleted{get{return _deletable.Deleted;}} 
    public DateTime ModifiedDate { 
    // and so on as above 
} 

Answer 6

是有方法，有幾個，其實。有幾個想法：

• 用空接口​​，Modifiable等（稱爲標記接口），然後爲它們創建擴展方法。這不像多重繼承那樣可擴展，但它有很長的路要走。
• 使用通用性，可能使用相同的標記接口來創建依賴關係。這種方式可以有兩種修改的，並且可刪除所有方法的基類，包括抽象方法，並在派生類中重寫實現
• 使用面向方面的編程，以獲得相同的結果
• 幾乎相同，但自己做與城堡或類似的圖書館，可能與屬性的幫助。

很明顯，以上都不具備多重繼承的全部優點。如果你想在.NET中使用多繼承，你可以使用C++ .NET或Eiffel.NET。

Answer 7

我忘了設計模式的名字，但有通過圍繞成員的接口實現的方法/屬性調用誰是相同的接口，以實現多個接口模式：

interface IDrivable { 
    void Drive(); 
} 

interface IFlyable { 
    void Fly(); 
} 

class Car : IDrivable { 
    public void Drive() { /* Implementation */ } 
} 

class Plane : IFlyable { 
    public void Fly() { /* Implementation */ } 
} 

class MyClass : IDrivable, IFlyable { 
    private IDrivable _car = new Car(); 
    private IFlyable _plane = new Plane(); 

    public void Drive() { _car.Drive(); } 
    public void Fly() { _plane.Fly(); } 
}