Implementazione dell'interfaccia IList

Question

Sono nuovo per i generici. Voglio implementare la mia collezione derivandola dall'interfaccia IList<T>.

Potete per favore fornirmi qualche link a una classe che implementa l'interfaccia IList<T> o mi fornire un codice che implementa almeno Add e Remove metodi?

Answer 1

A meno che non si abbia una ragione molto convincente per farlo, la soluzione migliore è quella di ereditare da System.Collections.ObjectModel.Collection<T> poiché ha tutto ciò che serve.

Si prega di notare che, anche se gli implementatori di IList<T> non sono tenuti ad implementare this[int] (indicizzatore) di essere O (1) (in pratica, l'accesso costante di tempo), è fortemente consigliato di farlo.

Answer 2

È possibile guardare Mono project. Sono disponibili codici sorgente completi, e puoi vedere come sono implementate alcune classi. Ad esempio "System.Collections.Generics.List < T>".

Answer 3

Nella maggior parte dei casi è sufficiente utilizzare List<T> o derivare da List<T>. Se si deriva da List<T>, si otterrà automaticamente l'implementazione per Aggiungi e Rimuovi.

Answer 4

Oltre a derivare da List<T>, è possibile la facciata List<T> e aggiungere ulteriori funzioni alla classe della facciata.

class MyCollection<T> : IList<T> 
{ 
    private readonly IList<T> _list = new List<T>(); 

    #region Implementation of IEnumerable 

    public IEnumerator<T> GetEnumerator() 
    { 
     return _list.GetEnumerator(); 
    } 

    IEnumerator IEnumerable.GetEnumerator() 
    { 
     return GetEnumerator(); 
    } 

    #endregion 

    #region Implementation of ICollection<T> 

    public void Add(T item) 
    { 
     _list.Add(item); 
    } 

    public void Clear() 
    { 
     _list.Clear(); 
    } 

    public bool Contains(T item) 
    { 
     return _list.Contains(item); 
    } 

    public void CopyTo(T[] array, int arrayIndex) 
    { 
     _list.CopyTo(array, arrayIndex); 
    } 

    public bool Remove(T item) 
    { 
     return _list.Remove(item); 
    } 

    public int Count 
    { 
     get { return _list.Count; } 
    } 

    public bool IsReadOnly 
    { 
     get { return _list.IsReadOnly; } 
    } 

    #endregion 

    #region Implementation of IList<T> 

    public int IndexOf(T item) 
    { 
     return _list.IndexOf(item); 
    } 

    public void Insert(int index, T item) 
    { 
     _list.Insert(index, item); 
    } 

    public void RemoveAt(int index) 
    { 
     _list.RemoveAt(index); 
    } 

    public T this[int index] 
    { 
     get { return _list[index]; } 
     set { _list[index] = value; } 
    } 

    #endregion 

    #region Your Added Stuff 

    // Add new features to your collection. 

    #endregion 
} 

Answer 5

Ereditando dalla lista è spesso l'approccio più veloce, ma può essere limitante in seguito su tutta la linea, se avete bisogno di ereditare da un'altra classe (ad esempio ContextBoundObject etc.). È abbastanza veloce implementare IList e, come sottolineato sopra, offre molta più flessibilità.