類型參數的約束：接口與抽象類

Question

創建一個帶有Name屬性的項目的簡單列表（UniqueList），該屬性只能包含唯一項目（定義爲具有不同的名稱）。在UniqueList類型的約束可以是一個接口：

interface INamed 
{ 
    string Name { get;} 
} 

或抽象類：

public abstract class NamedItem 
{ 
    public abstract string Name { get; } 
} 

所以UniqueList可以是：

class UniqueList<T> : List<T> where T : INamed 

或

class UniqueList<T> : List<T> where T : NamedItem 

類函數AddUni闕：

public T AddUnique(T item) 
{ 
    T result = Find(x => x.Name == item.Name); 
    if (result == default(T)) 
    { 
     Add(item); 
     return item; 
    } 
    return result; 
} 

如果類類型約束是基於接口上，編譯結果

Error: Operator '==' cannot be applied to operands of type 'T' and 'T' 

在該行

if (result == default(T)) 

一切都很好，如果我基地UniqueList於抽象類。有什麼想法嗎？

Answer 1

這是因爲接口可以應用於一個值類型的結構。爲了使其與接口工作擴展這樣的約束：

class UniqueList<T> : List<T> where T : INamed, class 

，將確保你將不能夠通過一個結構作爲T因此default(T)將評估爲null這是你所期望的。

---

另外，我建議您概括一個UniqueList位，允許不同類型的唯一密鑰：

interface IUnique<TKey> 
{ 
    TKey UniqueKey { get;} 
} 

class UniqueList<TItem,Tkey> : List<TItem> where TItem : IUnique<TKey>, class 

然後INamed接口，可以很容易地聲明：

interface INamed : IUnique<string> 
{ 
    string Name { get;} 
} 

UniqueKey或Name將在實現類中明確地實現以防止不必要的事實）公共班級成員。

Answer 2

是的。使用抽象類爲您提供==運算符的System.Object實現，而使用接口並不能保證編譯器該類型將支持==運算符，因爲它可能是一個沒有實現的結構。如果您將class約束添加到您的類型參數，它應該編譯。

Answer 3

該接口不提供Equals的實現，因此您無法比較這些項目。

順便說一下，你好像要重新實現HashSet，請考慮使用官方提供的類來代替。

Answer 4

我不明白爲什麼AddUnique必須使用Find與default比較，你能不能用Count與0比較？

if Count(x => x.Name == item.Name) = 0 { 
    .... 

UniqueList<T>好像有IEqualityComparer是比較T.Name

Answer 5

我建議你實現IEquatable<>並留下比較邏輯的類創建的HashSet。也請不要使用==作爲參考類型（strings），因爲它會檢查它是否是相同的對象，而不是它們是否相等。爲了迴應他人，我建議您使用Dictionary<>來檢查唯一的項目，或者只使用現有的KeyedCollection<string, INamed>，它保留索引列表以及字典。

public interface INamed : IEquatable<INamed> 
{ 
    string Name { get;} 
} 

public abstract class NamedItem : INamed 
{ 
    public abstract string Name { get; } 
    public bool Equals(INamed other) 
    { 
     if(other==null) return false;   
     return Name.Equals(other.Name); 
    } 
} 

public class UniqueList<T> : List<T> 
    where T : INamed 
{ 

    public T AddUnique(T item) 
    { 
     int index = FindIndex((x) => item.Equals(x)); 
     if (index < 0) 
     { 
      Add(item); 
      return item; 
     } 
     else 
     { 
      return this[index]; 
     } 
    } 
} 

Answer 6

您是否嘗試過在此行的某處定義您的接口？

interface INamed : IEqualityComparer<T> 
{ 
    string Name { get;} 
} 

然後在你的方法做

public T AddUnique(T item) 
{ 
    T result = Find(x => x.Name == item.Name); 
    if (result.Equals(default(T))) 
    { 
     Add(item); 
     return item; 
    } 
    return result; 
} 

注：上面的代碼沒有進行測試，可能需要調整

Answer 7

下面是使用KeyedCollection<>基類的第2個答案。

class Program 
{ 

    static void Main(string[] args) 
    { 
     UniqueList<IntValue> list = new UniqueList<IntValue>(); 

     list.Add(new IntValue("Smile", 100)); 
     list.Add(new IntValue("Frown", 101)); 
     list.Add(new IntValue("Smile", 102)); // Error, key exists already 
     int x = list["Smile"].Value; 
     string frown = list[1].Name; 
    } 
} 

public interface INamed : IEquatable<INamed> 
{ 
    string Name { get;} 
} 

public abstract class NamedItem : INamed 
{ 
    public abstract string Name { get; } 
    public bool Equals(INamed other) 
    { 
     if(other==null) return false;   
     return Name.Equals(other.Name); 
    } 
} 

public class IntValue : NamedItem 
{ 
    string name; 
    int value; 

    public IntValue(string name, int value) 
    { 
     this.name = name; 
     this.value = value; 
    } 

    public override string Name { get { return name; } } 
    public int Value { get { return value; } } 
} 

public class UniqueList<T> : KeyedCollection<string, T> 
    where T : INamed 
{ 
    protected override string GetKeyForItem(T item) 
    { 
     return item.Name; 
    } 

} 

Answer 8

我會提出一個解決方案，使用「鴨打字」。鴨子在這個實例中鍵入意味着「如果它有一個名爲的字符串屬性名稱，那麼它是可用的。」鴨子打字不依賴於接口或抽象基類。

我從KeyedCollection獲得集合類，因爲此類已提供關鍵支持，但其他類（包括List<T>）也是可能的。

class NamedItemCollection<T> : KeyedCollection<string, T> { 

    private static readonly Func<T, string> keyProvider; 

    static NamedItemCollection() { 
     var x = Expression.Parameter(typeof(T), "x"); 
     var expr = Expression.Lambda<Func<T, string>>(
      Expression.Property(x, "Name"), 
      x); 
     keyProvider = expr.Compile(); 
    } 

    protected override string GetKeyForItem(T item) { 
     return keyProvider(item); 
    } 

} 

該類首次與特定類型參數一起使用時，我們使用動態代碼生成來編譯一個小方法。該方法以類型安全的方式讀取name屬性 - 不管容器類型如何！

public abstract class NamedItem { public abstract string Name { get; } } 
struct Thing { public string Name { get; set; } } 

var namedItems1 = new NamedItemCollection<NamedItem>(); 
var namedItems2 = new NamedItemCollection<Thing>(); 
var namedItems3 = new NamedItemCollection<Type>(); 

Answer 9

的約束添加到你的T的建議是好的，因爲它代表的問題是 - 正如其他人所說 - 那你的T不保證實現==操作符。不過，它會實現Equals方法，所以你可以用它來代替......如果你不想將泛型限制在一個獨一無二的基於引用或基於值的實現中，這很方便。

在Blindy的評論後，有一個警告。雖然Equals在所有對象類型上都是合法的，但如果源對象爲null（即null.Equals（...）會引發運行時錯誤），那麼這是不合法的，並且在T是類的情況下，它的默認值將爲空，因此在嘗試調用空引用上的Equals之前，您需要考慮該情況。

這裏是我的代碼，同時使用類的結構實現：

public interface INamed 
{ 
    string Name { get; set; } 
} 

public class Foo<T> 
    : List<T> 
    where T : INamed 
{ 
    public bool IsUnique(T item) 
    { 
     T result = Find(x => x.Name == item.Name); 
     if (result == null || result.Equals(default(T))) 
      return true; 
     return false; 
    } 
} 

public class BarClass : INamed 
{ 
    public string Name { get; set; } 
} 
public struct BarStruct : INamed 
{ 
    public string Name { get; set; } 
} 
[STAThread] 
static void Main() 
{ 
    BarClass bc = new BarClass { Name = "test" }; 
    Foo<BarClass> fc = new Foo<BarClass>(); 
    fc.IsUnique(bc); 

    BarStruct bs = new BarStruct { Name = "test" }; 
    Foo<BarStruct> fs = new Foo<BarStruct>(); 
    fs.IsUnique(bs); 
}