Skillnaden mellan IEnumerable, ICollection och IList Interface i C#

Skillnaden mellan IEnumerable, ICollection och IList Interface i C#

I den här artikeln kommer vi att förstå:

  • Vad är IEnumerable-gränssnitt och när ska det användas?

  • Vad är ICollection Interface och när ska det användas?

  • Vad är IList  gränssnitt och när ska det användas?

IEnumerable Interface:

Det finns två olika gränssnitt definierade i .NET-basklassbiblioteket. Det finns en icke-generisk IEnumerable gränssnitt och det finns en generisk typsäker IEnumerable gränssnittet

IEnumerable :

IEnumerable gränssnittet innehåller endast en enda metoddefinition, dvs. GetEnumerator() och GetEnumerator-metoden måste returnera en instans av ett objekt av en klass som implementerar IEnumerator gränssnitt


public interface IEnumerable
{
    IEnumerator GetEnumerator();
}

IEnumerable:

  • IEnumerable är ett generiskt typsäkert gränssnitt och finns i System.Collections.Generic namnutrymme.
  • IEnumerable ärver från IEnumerable Interface.
  • IEnumerable definierar en enda metod GetEnumerator som returnerar en instans av ett objekt som implementerar IEnumerator-gränssnittet.

public interface IEnumerable<out T> : IEnumerable
{
 IEnumerator GetEnumerator();
}

ICollection Interface:

Det finns två olika gränssnitt definierade i .NET-basklassbiblioteket. Det finns en icke-generisk ICollection  gränssnitt och det finns en generisk typsäker ICollection gränssnittet

ICollection :

public interface ICollection : IEnumerable
{
    int Count { get; }  
    bool IsSynchronized { get; }
    Object SyncRoot { get; } 
    void CopyTo(Array array, int index);
}

ICollection-gränssnittet innehåller följande egenskaper:

  • Räkna egendom
  • IsSynchronized Property
  • SyncRoot-egenskap
  • CopyTo-metod

The Count egenskapen används för att upprätthålla antalet element i listan

Egenskaperna IsSysnchronized och SyncRoot hjälper till att göra samlingen trådsäker.

CopyTo-metoden kopierar hela samlingen till en array.

Den generiska versionen av det här gränssnittet tillhandahåller även Lägg till och ta bort metoder.

IKamling:

Detta är den generiska versionen av ICollection Interface.

public interface ICollection : IEnumerable, IEnumerable
{
    int Count { get; }
    bool IsReadOnly { get; } 
    void Add(T item);
    void Clear();
    bool Contains(T item);
    void CopyTo(T[] array, int arrayIndex);
    bool Remove(T item);
}

IList-gränssnitt:

IList har också generisk och icke-generisk version, dvs. IList och IList

IList :

public interface IList : ICollection, IEnumerable
{
    bool IsFixedSize { get; }
    bool IsReadOnly { get; }
    Object this[int index] { get; set; } 
    int Add(Object value);
    void Clear();
    bool Contains(Object value);
    int IndexOf(Object value);
    void Insert(int index, Object value);
    void Remove(Object value);
    void RemoveAt(int index);
}

IList-gränssnittet innehåller följande:

  1. IsFixedSize-egenskap
  2. IsReadOnly Property
  3. Indexerare
  4. Lägg till metod
  5. Rensa metod
  6. Innehåller metod
  7. Index för metod
  8. Infoga metod
  9. Ta bort metod
  10. RemoveAt-metoden

IList-gränssnittet har en indexerare med vilken vi kan komma åt vilket element som helst genom dess position och kan infoga ett element och ta bort ett element vid vilken position som helst.

IList :


public interface IList : ICollection, IEnumerable, IEnumerable
{
    T this[int index] { get; set; }
     int IndexOf(T item);
    void Insert(int index, T item);
    void RemoveAt(int index);
}

När ska jag använda det?

Nu eftersom vi känner till alla gränssnitt är nästa fråga vi har när vi måste använda vilket gränssnitt?

Den viktiga punkten är att använda gränssnittet som vår applikation behöver oss att använda.

Gränssnitt Bästa metoder
IEnumerable, IEnumerable Det enda du vill är att iterera över elementen i en samling.

Du behöver bara skrivskyddad åtkomst till den samlingen.

ICollection, ICollection Du vill modifiera samlingen eller så bryr du dig om dess storlek.
IList, IList Du vill modifiera samlingen och du bryr dig om ordningen och/eller placeringen av elementen i samlingen.
Lista, lista Per DIP bör du vara beroende av abstraktioner istället för implementeringar, du bör aldrig ha en medlem av dina egna implementeringar med den konkreta typen List/List.