タイプパラメータの制約：インターフェイスと抽象クラス

Question

Nameプロパティを持つ項目の単純なリスト（UniqueList）には、一意の項目（名前が異なると定義されている）のみが含まれていなければなりません。

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

だからUniqueListができ：

interface INamed 
{ 
    string Name { get;} 
} 

または抽象クラス：

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

または

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

UniqueListタイプの制約は、インターフェースすることができ

クラス関数AddUni QUE：ラインで

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

で

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

クラス型制約は、インターフェイスに基づいている場合、コンパイル結果

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は、実装クラス内で明示的にimplemetedされ、不要な（実際は）パブリッククラスメンバー。

Answer 2

はい。抽象クラスを使用すると、==演算子のSystem.Object実装が提供されますが、インタフェースを使用すると、実装がない構造体である可能性があるため、型が==演算子をサポートすることがコンパイラに保証されません。型パラメータにclassという制約を追加すると、コンパイルする必要があります。

Answer 3

インターフェイスはEqualsの実装を提供しないため、アイテムを比較することはできません。

ところで、あなたはHashSetを再実装しているようですが、代わりに公式提供クラスの使用を検討してください。

Answer 4

AddUniqueあなたはCountを使用して0と比較することはできません、Findを使用してdefaultと比較しなければならない理由を私は理解していませんか？

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

UniqueList<T>私はあなたがIEquatable<>を実装したクラスに比較ロジックを残す示唆T.Name

Answer 5

を比較IEqualityComparerで作成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<>基本クラスを使用して第二の答えです。

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プロパティを読み取ります。他の人が言及したように - - あなたのTは、==演算子を実装するために保証されていないことを、そのままで問題があるので、あなたのTに制約を追加する

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

提案は、良いものです。ただし、Equalsメソッドを実装するので、代わりに使用することができます。これは、ジェネリックを排他的参照または値ベースの実装に制限したくない場合に便利です。

Blindyのコメント後、警告があります。 Equalsはすべてのオブジェクト型で正当ですが、ソースオブジェクトがnullの場合（つまり、null.Equals（...）は実行時エラーをスローします）、Tがクラスの場合はデフォルトnullであるため、null参照で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); 
}