Der beste Weg, um Elemente aus einer Sammlung zu entfernen

Was ist der beste Weg, um Elemente aus einer Sammlung in C # zu entfernen, sobald das Element bekannt ist, aber nicht der Index. Dies ist eine Möglichkeit, aber es scheint bestenfalls unelegant.

//Remove the existing role assignment for the user.
int cnt = 0;
int assToDelete = 0;
foreach (SPRoleAssignment spAssignment in workspace.RoleAssignments)
{
    if (spAssignment.Member.Name == shortName)
    {
        assToDelete = cnt;
    }
    cnt++;
}
workspace.RoleAssignments.Remove(assToDelete);

Was ich wirklich gerne tun würde, ist das zu entfernende Element nach Eigenschaft (in diesem Fall Name) zu finden, ohne die gesamte Sammlung zu durchlaufen und 2 zusätzliche Variablen zu verwenden.

Wenn Sie über eine ihrer Eigenschaften auf Mitglieder der Sammlung zugreifen möchten, können Sie ein Dictionary<T>oder KeyedCollection<T>stattdessen verwenden. Auf diese Weise müssen Sie nicht nach dem gesuchten Artikel suchen.

Andernfalls könnten Sie zumindest Folgendes tun:

foreach (SPRoleAssignment spAssignment in workspace.RoleAssignments)
{
    if (spAssignment.Member.Name == shortName)
    {
        workspace.RoleAssignments.Remove(spAssignment);
        break;
    }
}

Wenn RoleAssignments a ist List<T>, können Sie den folgenden Code verwenden.

workSpace.RoleAssignments.RemoveAll(x =>x.Member.Name == shortName);

@smaclell fragte in einem Kommentar zu @ sambo99, warum die umgekehrte Iteration effizienter sei.

Manchmal ist es effizienter. Stellen Sie sich vor, Sie haben eine Personenliste und möchten alle Kunden mit einer Bonität <1000 entfernen oder filtern.

Wir haben die folgenden Daten

"Bob" 999
"Mary" 999
"Ted" 1000

Wenn wir vorwärts iterieren würden, würden wir bald in Schwierigkeiten geraten

for( int idx = 0; idx < list.Count ; idx++ )
{
    if( list[idx].Rating < 1000 )
    {
        list.RemoveAt(idx); // whoops!
    }
}

Bei idx = 0 entfernen wir Bob, wodurch alle verbleibenden Elemente nach links verschoben werden . Das nächste Mal durch die Schleife ist idx = 1, aber Liste [1] ist jetzt Tedstatt Mary. Wir überspringen Maryversehentlich. Wir könnten eine while-Schleife verwenden und weitere Variablen einführen.

Oder wir kehren einfach die Iteration um:

for (int idx = list.Count-1; idx >= 0; idx--)
{
    if (list[idx].Rating < 1000)
    {
        list.RemoveAt(idx);
    }
}

Alle Indizes links vom entfernten Element bleiben gleich, sodass Sie keine Elemente überspringen.

Das gleiche Prinzip gilt, wenn Sie eine Liste von Indizes erhalten, die aus einem Array entfernt werden sollen. Um die Dinge gerade zu halten, müssen Sie die Liste sortieren und dann die Elemente vom höchsten zum niedrigsten Index entfernen.

Jetzt können Sie einfach Linq verwenden und auf einfache Weise deklarieren, was Sie tun.

list.RemoveAll(o => o.Rating < 1000);

In diesem Fall ist es nicht effizienter, ein einzelnes Element vorwärts oder rückwärts zu iterieren. Sie können hierfür auch Linq verwenden.

int removeIndex = list.FindIndex(o => o.Name == "Ted");
if( removeIndex != -1 )
{
    list.RemoveAt(removeIndex);
}

Wenn es eine ist, ICollectiondann haben Sie keine RemoveAllMethode. Hier ist eine Erweiterungsmethode, die dies ermöglicht:

    public static void RemoveAll<T>(this ICollection<T> source, 
                                    Func<T, bool> predicate)
    {
        if (source == null)
            throw new ArgumentNullException("source", "source is null.");

        if (predicate == null)
            throw new ArgumentNullException("predicate", "predicate is null.");

        source.Where(predicate).ToList().ForEach(e => source.Remove(e));
    }

Basierend auf: http://phejndorf.wordpress.com/2011/03/09/a-removeall-extension-for-the-collection-class/

Für eine einfache Listenstruktur scheint der effizienteste Weg die Verwendung der Predicate RemoveAll-Implementierung zu sein.

Z.B.

 workSpace.RoleAssignments.RemoveAll(x =>x.Member.Name == shortName);

Die Gründe sind:

1. Die Predicate / Linq RemoveAll-Methode ist in List implementiert und hat Zugriff auf das interne Array, in dem die tatsächlichen Daten gespeichert sind. Dadurch werden die Daten verschoben und die Größe des internen Arrays geändert.
2. Die Implementierung der RemoveAt-Methode ist recht langsam und kopiert das gesamte zugrunde liegende Datenarray in ein neues Array. Dies bedeutet, dass die umgekehrte Iteration für List unbrauchbar ist

Wenn Sie dies in der Zeit vor C # 3.0 nicht weiter implementieren können. Sie haben 2 Möglichkeiten.

• Die leicht zu wartende Option. Kopieren Sie alle übereinstimmenden Elemente in eine neue Liste und tauschen Sie die zugrunde liegende Liste aus.

Z.B.

List<int> list2 = new List<int>() ; 
foreach (int i in GetList())
{
    if (!(i % 2 == 0))
    {
        list2.Add(i);
    }
}
list2 = list2;

Oder

• Die knifflige, etwas schnellere Option, bei der alle Daten in der Liste nach unten verschoben werden, wenn sie nicht übereinstimmen, und anschließend die Größe des Arrays geändert wird.

Wenn Sie sehr häufig Dinge aus einer Liste entfernen, ist möglicherweise eine andere Struktur wie eine HashTable (.net 1.1) oder ein Dictionary (.net 2.0) oder ein HashSet (.net 3.5) für diesen Zweck besser geeignet.

Welcher Typ ist die Sammlung? Wenn es List ist, können Sie das hilfreiche "RemoveAll" verwenden:

int cnt = workspace.RoleAssignments
                      .RemoveAll(spa => spa.Member.Name == shortName)

(Dies funktioniert in .NET 2.0. Wenn Sie nicht über den neueren Compiler verfügen, müssen Sie natürlich "delegate (SPRoleAssignment spa) {return spa.Member.Name == shortName;}" anstelle des nice verwenden Lambda-Syntax.)

Ein anderer Ansatz, wenn es sich nicht um eine Liste, sondern um eine ICollection handelt:

   var toRemove = workspace.RoleAssignments
                              .FirstOrDefault(spa => spa.Member.Name == shortName)
   if (toRemove != null) workspace.RoleAssignments.Remove(toRemove);

Dies erfordert die Enumerable-Erweiterungsmethoden. (Sie können die Mono-Dateien kopieren, wenn Sie mit .NET 2.0 nicht weiterkommen.) Wenn es sich um eine benutzerdefinierte Sammlung handelt, die kein Element aufnehmen kann, aber einen Index verwenden MUSS, übergeben einige der anderen Enumerable-Methoden, z. B. Select, den ganzzahligen Index für Sie.

Dies ist meine generische Lösung

public static IEnumerable<T> Remove<T>(this IEnumerable<T> items, Func<T, bool> match)
    {
        var list = items.ToList();
        for (int idx = 0; idx < list.Count(); idx++)
        {
            if (match(list[idx]))
            {
                list.RemoveAt(idx);
                idx--; // the list is 1 item shorter
            }
        }
        return list.AsEnumerable();
    }

Es würde viel einfacher aussehen, wenn Erweiterungsmethoden das Übergeben von Referenzen unterstützen würden! Verwendung:

var result = string[]{"mike", "john", "ali"}
result = result.Remove(x => x.Username == "mike").ToArray();
Assert.IsTrue(result.Length == 2);

BEARBEITEN: Sichergestellt, dass die Listenschleife auch beim Löschen von Elementen gültig bleibt, indem der Index (idx) dekrementiert wird.

Hier ist ein ziemlich guter Weg, dies zu tun

http://support.microsoft.com/kb/555972

        System.Collections.ArrayList arr = new System.Collections.ArrayList();
        arr.Add("1");
        arr.Add("2");
        arr.Add("3");

        /*This throws an exception
        foreach (string s in arr)
        {
            arr.Remove(s);
        }
        */

        //where as this works correctly
        Console.WriteLine(arr.Count);
        foreach (string s in new System.Collections.ArrayList(arr)) 
        {
            arr.Remove(s);
        }
        Console.WriteLine(arr.Count);
        Console.ReadKey();

Je nachdem, wie Sie Ihre Sammlung verwenden, können Sie einen anderen Ansatz wählen. Wenn Sie die Aufgaben einmal herunterladen (z. B. wenn die App ausgeführt wird), können Sie die Sammlung im laufenden Betrieb in eine Hashtabelle übersetzen, in der:

Kurzname => SPRoleAssignment

Wenn Sie dies tun, müssen Sie beim Entfernen eines Elements mit Kurznamen lediglich das Element mit dem Schlüssel aus der Hashtabelle entfernen.

Wenn Sie diese SPRoleAssignments häufig laden, ist dies leider zeitlich nicht kosteneffizienter. Die Vorschläge anderer Leute zur Verwendung von Linq wären gut, wenn Sie eine neue Version von .NET Framework verwenden. Andernfalls müssen Sie sich an die von Ihnen verwendete Methode halten.

Ähnlich wie bei Dictionary Collection habe ich dies getan.

Dictionary<string, bool> sourceDict = new Dictionary<string, bool>();
sourceDict.Add("Sai", true);
sourceDict.Add("Sri", false);
sourceDict.Add("SaiSri", true);
sourceDict.Add("SaiSriMahi", true);

var itemsToDelete = sourceDict.Where(DictItem => DictItem.Value == false);

foreach (var item in itemsToDelete)
{
    sourceDict.Remove(item.Key);
}

Hinweis: Der obige Code schlägt im .Net-Client-Profil (3.5 und 4.5) fehl. Einige Betrachter haben auch erwähnt, dass er in .Net4.0 nicht funktioniert. Sie sind sich nicht sicher, welche Einstellungen das Problem verursachen.

Ersetzen Sie daher die Where-Anweisung durch den folgenden Code (.ToList ()), um diesen Fehler zu vermeiden. „Die Sammlung wurde geändert. Aufzählungsoperation wird möglicherweise nicht ausgeführt. “

var itemsToDelete = sourceDict.Where(DictItem => DictItem.Value == false).ToList();

Pro MSDN Ab .Net4.5 werden Client-Profile eingestellt. http://msdn.microsoft.com/en-us/library/cc656912(v=vs.110).aspx

Speichern Sie Ihre Artikel zuerst und löschen Sie sie dann.

var itemsToDelete = Items.Where(x => !!!your condition!!!).ToArray();
for (int i = 0; i < itemsToDelete.Length; ++i)
    Items.Remove(itemsToDelete[i]);

Sie müssen GetHashCode()in Ihrer Artikelklasse überschreiben .

Der beste Weg, dies zu tun, ist die Verwendung von linq.

Beispielklasse:

 public class Product
    {
        public string Name { get; set; }
        public string Price { get; set; }      
    }

Linq-Abfrage:

var subCollection = collection1.RemoveAll(w => collection2.Any(q => q.Name == w.Name));

Diese Abfrage wird alle Elemente entfernen , collection1wenn Namejedes Element übereinstimmen Nameauscollection2

Denken Sie daran, Folgendes zu verwenden: using System.Linq;

Dies ist der Ansatz, den ich in der Vergangenheit gewählt habe (beachten Sie die .ToList () am Ende der ursprünglichen Sammlung. Dadurch wird eine weitere Sammlung im Speicher erstellt , dann können Sie die vorhandene Sammlung ändern)

foreach (SPRoleAssignment spAssignment in workspace.RoleAssignments.ToList())
{
    if (spAssignment.Member.Name == shortName)
    {
        workspace.RoleAssignments.Remove(spAssignment);
    }
}

Wenn Sie eine haben List<T>, dann List<T>.RemoveAllist Ihre beste Wahl. Effizienter kann es nicht sein. Intern bewegt sich das Array in einem Schuss, ganz zu schweigen von O (N).

Wenn Sie nur ein IList<T>oder ein haben, haben ICollection<T>Sie ungefähr diese drei Optionen:

    public static void RemoveAll<T>(this IList<T> ilist, Predicate<T> predicate) // O(N^2)
    {
        for (var index = ilist.Count - 1; index >= 0; index--)
        {
            var item = ilist[index];
            if (predicate(item))
            {
                ilist.RemoveAt(index);
            }
        }
    }

oder

    public static void RemoveAll<T>(this ICollection<T> icollection, Predicate<T> predicate) // O(N)
    {
        var nonMatchingItems = new List<T>();

        // Move all the items that do not match to another collection.
        foreach (var item in icollection) 
        {
            if (!predicate(item))
            {
                nonMatchingItems.Add(item);
            }
        }

        // Clear the collection and then copy back the non-matched items.
        icollection.Clear();
        foreach (var item in nonMatchingItems)
        {
            icollection.Add(item);
        }
    }

oder

    public static void RemoveAll<T>(this ICollection<T> icollection, Func<T, bool> predicate) // O(N^2)
    {
        foreach (var item in icollection.Where(predicate).ToList())
        {
            icollection.Remove(item);
        }
    }

Wählen Sie entweder 1 oder 2.

1 ist leichter im Speicher und schneller, wenn Sie weniger Löschvorgänge ausführen müssen (dh das Prädikat ist meistens falsch).

2 ist schneller, wenn Sie mehr Löschvorgänge ausführen müssen.

3 ist der sauberste Code, hat aber eine schlechte IMO-Leistung. Auch hier hängt alles von den Eingabedaten ab.

Einige Details zum Benchmarking finden Sie unter https://github.com/dotnet/BenchmarkDotNet/issues/1505

Viele gute Antworten hier; Ich mag besonders die Lambda-Ausdrücke ... sehr sauber. Ich habe es jedoch versäumt, die Art der Sammlung nicht anzugeben. Dies ist eine SPRoleAssignmentCollection (von MOSS), die nur Remove (int) und Remove (SPPrincipal) enthält, nicht das praktische RemoveAll (). Also habe ich mich darauf geeinigt, es sei denn, es gibt einen besseren Vorschlag.

foreach (SPRoleAssignment spAssignment in workspace.RoleAssignments)
{
    if (spAssignment.Member.Name != shortName) continue;
    workspace.RoleAssignments.Remove((SPPrincipal)spAssignment.Member);
    break;
}