CA1010: Sammlungen müssen eine generische Schnittstelle implementieren.

  • Artikel
Eigenschaft Wert
Regel-ID CA1010
Titel Sammlungen müssen eine generische Schnittstelle implementieren.
Kategorie Design
Fix führt oder führt nicht zur Unterbrechung Nicht unterbrechend
Standardmäßig in .NET 8 aktiviert Nein

Ursache

Ein Typ implementiert die System.Collections.IEnumerable-Schnittstelle, implementiert aber nicht die System.Collections.Generic.IEnumerable<T>-Schnittstelle, und die enthaltende Assembly zielt auf .NET ab. Diese Regel ignoriert Typen, die System.Collections.IDictionary implementieren.

Standardmäßig werden mit dieser Regel nur extern sichtbare Typen überprüft, aber dies ist konfigurierbar. Sie können auch zusätzliche Schnittstellen konfigurieren, die erfordern, dass eine generische Schnittstelle implementiert wird.

Regelbeschreibung

Um die Verwendbarkeit einer Auflistung zu erweitern, implementieren Sie eine der generischen Auflistungsschnittstellen. Anschließend kann die Auflistung zum Auffüllen generischer Auflistungstypen verwendet werden, wie beispielsweise die folgenden:

Behandeln von Verstößen

Um einen Verstoß gegen diese Regel zu beheben, müssen Sie eine der folgenden generischen Auflistungsschnittstellen implementieren:

Wann sollten Warnungen unterdrückt werden?

Es ist sicher, eine Warnung aus dieser Regel zu unterdrücken. Allerdings schränkt sich die Verwendung der Auflistung weiter ein.

Unterdrücken einer Warnung

Um nur eine einzelne Verletzung zu unterdrücken, fügen Sie der Quelldatei Präprozessoranweisungen hinzu, um die Regel zu deaktivieren und dann wieder zu aktivieren.

#pragma warning disable CA1010
// The code that's violating the rule is on this line.
#pragma warning restore CA1010

Um die Regel für eine Datei, einen Ordner oder ein Projekt zu deaktivieren, legen Sie den Schweregrad in der Konfigurationsdatei auf none fest.

[*.{cs,vb}]
dotnet_diagnostic.CA1010.severity = none

Weitere Informationen finden Sie unter Vorgehensweise: Unterdrücken von Codeanalyse-Warnungen.

Konfigurieren des zu analysierenden Codes

Mit den folgenden Optionen können Sie konfigurieren, für welche Teile Ihrer Codebasis diese Regel ausgeführt werden soll.

Sie können diese Optionen nur für diese Regel, für alle zutreffenden Regeln oder für alle zutreffenden Regeln in dieser Kategorie (Entwurf) konfigurieren. Weitere Informationen finden Sie unter Konfigurationsoptionen für die Codequalitätsregel.

Einschließen bestimmter API-Oberflächen

Sie können je nach Zugänglichkeit festlegen, für welche Bestandteile Ihrer Codebasis diese Regel ausgeführt wird. Sie können beispielsweise festlegen, dass die Regel nur für die nicht öffentliche API-Oberfläche ausgeführt werden soll, indem Sie einer EDITORCONFIG-Datei in Ihrem Projekt das folgende Schlüssel-Wert-Paar hinzufügen:

dotnet_code_quality.CAXXXX.api_surface = private, internal

Weitere erforderliche generische Schnittstellen

Sie können die Liste der Schnittstellennamen (getrennt durch |) mit der erforderlichen generischen vollqualifizierten Oberfläche (getrennt durch ->) konfigurieren.

Zulässige Schnittstellenformate:

  • Nur Schnittstellenname (schließt alle Schnittstellen mit dem Namen ein, unabhängig vom enthaltenden Typ oder Namespace).
  • Vollqualifizierte Namen im Dokumentations-ID-Format des Symbols mit einem optionalen Präfix T:.

Beispiele:

Optionswert Zusammenfassung
dotnet_code_quality.CA1010.additional_required_generic_interfaces = ISomething->System.Collections.Generic.IEnumerable`1 Alle Typen, die ISomething implementieren, unabhängig von Ihrem Namespace, müssen ebenfalls System.Collections.Generic.IEnumerable<T>implementieren.
dotnet_code_quality.CA1010.additional_required_generic_interfaces = T:System.Collections.IDictionary->T:System.Collections.Generic.IDictionary`2 Alle Typen, die System.Collections.IDictionary implementieren, sollten ebenfalls System.Collections.Generic.IDictionary<TKey,TValue>implementieren.

Beispiel

Das folgende Beispiel zeigt eine Klasse, die von der nicht generischen CollectionBase-Klasse abgeleitet ist und gegen diese Regel verstößt.

public class Book
{
    public Book()
    {
    }
}

public class BookCollection : CollectionBase
{
    public BookCollection()
    {
    }

    public void Add(Book value)
    {
        InnerList.Add(value);
    }

    public void Remove(Book value)
    {
        InnerList.Remove(value);
    }

    public void Insert(int index, Book value)
    {
        InnerList.Insert(index, value);
    }

    public Book? this[int index]
    {
        get { return (Book?)InnerList[index]; }
        set { InnerList[index] = value; }
    }

    public bool Contains(Book value)
    {
        return InnerList.Contains(value);
    }

    public int IndexOf(Book value)
    {
        return InnerList.IndexOf(value);
    }

    public void CopyTo(Book[] array, int arrayIndex)
    {
        InnerList.CopyTo(array, arrayIndex);
    }
}

Führen Sie einen der folgenden Schritte aus, um einen Verstoß gegen diese Regel zu beheben:

Beheben durch Schnittstellenimplementierung

Im folgenden Beispiel wird die Verletzung durch Implementieren dieser generischen Schnittstellen korrigiert: IEnumerable<T> , ICollection<T> und IList<T>.

public class Book
{
    public Book()
    {
    }
}

public class BookCollection : CollectionBase, IList<Book?>
{
    public BookCollection()
    {
    }

    int IList<Book?>.IndexOf(Book? item)
    {
        return this.List.IndexOf(item);
    }

    void IList<Book?>.Insert(int location, Book? item)
    {
    }

    Book? IList<Book?>.this[int index]
    {
        get => (Book?)this.List[index];
        set { }
    }

    void ICollection<Book?>.Add(Book? item)
    {
    }

    bool ICollection<Book?>.Contains(Book? item)
    {
        return true;
    }

    void ICollection<Book?>.CopyTo(Book?[] array, int arrayIndex)
    {
    }

    bool ICollection<Book?>.IsReadOnly
    {
        get { return false; }
    }

    bool ICollection<Book?>.Remove(Book? item)
    {
        if (InnerList.Contains(item))
        {
            InnerList.Remove(item);
            return true;
        }
        return false;
    }

    IEnumerator<Book> IEnumerable<Book?>.GetEnumerator()
    {
        return new BookCollectionEnumerator(InnerList.GetEnumerator());
    }

    private class BookCollectionEnumerator : IEnumerator<Book>
    {
        private IEnumerator _Enumerator;

        public BookCollectionEnumerator(IEnumerator enumerator)
        {
            _Enumerator = enumerator;
        }

        public Book Current
        {
            get { return (Book)_Enumerator.Current; }
        }

        object IEnumerator.Current
        {
            get { return _Enumerator.Current; }
        }

        public bool MoveNext()
        {
            return _Enumerator.MoveNext();
        }

        public void Reset()
        {
            _Enumerator.Reset();
        }

        public void Dispose()
        {
        }
    }
}

Korrektur durch Basisklassenänderung

Im folgenden Beispiel wird die Verletzung durch Ändern der Basisklasse der Auflistung von der nicht generischen CollectionBase-Klasse in die generische-Klasse Collection<T> ( Collection(Of T) in Visual Basic) korrigiert.

public class Book
{
    public Book()
    {
    }
}

public class BookCollection : Collection<Book>
{
    public BookCollection()
    {
    }
}

Das Ändern der Basisklasse einer bereits freigegebenen Klasse wird als Breaking Change für vorhandene Consumer angesehen.

Weitere Informationen