CA2009: „ToImmutableCollection“ nicht für einen ImmutableCollection-Wert aufrufen.

Ursache

Die ToImmutable-Methode wurde unnötigerweise für eine unveränderliche Auflistung aus dem System.Collections.Immutable Namespace aufgerufen.

Regelbeschreibung

System.Collections.Immutable Namespace enthält Typen, die unveränderliche Auflistungen definieren. Diese Regel analysiert die folgenden unveränderlichen Auflistungstypen:

• System.Collections.Immutable.ImmutableArray<T>
• System.Collections.Immutable.ImmutableList<T>
• System.Collections.Immutable.ImmutableHashSet<T>
• System.Collections.Immutable.ImmutableSortedSet<T>
• System.Collections.Immutable.ImmutableDictionary<TKey,TValue>
• System.Collections.Immutable.ImmutableSortedDictionary<TKey,TValue>

Diese Typen definieren Erweiterungsmethoden, die eine neue unveränderliche Auflistung aus einer vorhandenen IEnumerable<T> Auflistung erstellen.

• ImmutableArray<T> definiert ToImmutableArray.
• ImmutableList<T> definiert ToImmutableList.
• ImmutableHashSet<T> definiert ToImmutableHashSet.
• ImmutableSortedSet<T> definiert ToImmutableSortedSet.
• ImmutableDictionary<TKey,TValue> definiert ToImmutableDictionary.
• ImmutableSortedDictionary<TKey,TValue> definiert ToImmutableSortedDictionary.

Diese Auflistungsmethoden sind so konzipiert, dass eine änderbare Auflistung in eine unveränderliche Auflistung konvertiert wird. Allerdings kann der Aufrufer versehentlich eine unveränderliche Auflistung als Eingabe an diese Methoden übergeben. Dies kann ein Leistungs- und/oder ein funktionales Problem darstellen.

• Leistungsproblem: Unnötige Boxing-, Unboxing- und/oder Laufzeittypüberprüfungen für eine unveränderliche Sammlung.
• Mögliches Funktionsproblem: der Aufrufer hat eine änderbare Auflistung angenommen, während es stattdessen eine unveränderliche Auflistung war.

Behandeln von Verstößen

Entfernen Sie den redundanten ToImmutable-Aufruf für eine unveränderliche Auflistung, um Verstöße zu beheben. Die folgenden beiden Codeausschnitte zeigen z. B. einen Verstoß gegen die Regel und wie dieser korrigiert werden kann:

using System;
using System.Collections.Generic;
using System.Collections.Immutable;

public class C
{
    public void M(IEnumerable<int> collection, ImmutableArray<int> immutableArray)
    {
        // This is fine.
        M2(collection.ToImmutableArray());

        // This leads to CA2009.
        M2(immutableArray.ToImmutableArray());
    }

    private void M2(ImmutableArray<int> immutableArray)
    {
        Console.WriteLine(immutableArray.Length);
    }
}

using System;
using System.Collections.Generic;
using System.Collections.Immutable;

public class C
{
    public void M(IEnumerable<int> collection, ImmutableArray<int> immutableArray)
    {
        // This is fine.
        M2(collection.ToImmutableArray());

        // This is now fine.
        M2(immutableArray);
    }

    private void M2(ImmutableArray<int> immutableArray)
    {
        Console.WriteLine(immutableArray.Length);
    }
}

Wann sollten Warnungen unterdrückt werden?

Unterdrücken Sie keine Verstöße gegen diese Regel, es sei denn, Sie haben keine Bedenken über die Auswirkungen auf die Leistung durch unnötige Zuordnungen unveränderlicher Auflistungen.

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 CA2009
// The code that's violating the rule is on this line.
#pragma warning restore CA2009

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.CA2009.severity = none

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

Siehe auch

• Zuverlässigkeitsregeln
• Leistungsregeln