C # 'da numaralandırırken List <T>' den öğeleri kaldırmanın akıllı yolu

Bir öğeyi bir döngüde numaralandırırken bir koleksiyondan kaldırmaya çalışmak gibi klasik bir durum var:

List<int> myIntCollection = new List<int>();
myIntCollection.Add(42);
myIntCollection.Add(12);
myIntCollection.Add(96);
myIntCollection.Add(25);

foreach (int i in myIntCollection)
{
    if (i == 42)
        myIntCollection.Remove(96);    // The error is here.
    if (i == 25)
        myIntCollection.Remove(42);    // The error is here.
}

Bir değişiklik gerçekleştikten sonra yinelemenin başında bir InvalidOperationExceptionatılır, çünkü numaralandırıcılar temeldeki koleksiyonun değişmesinden hoşlanmaz.

Yineleme sırasında koleksiyonda değişiklik yapmam gerekiyor. Bundan kaçınmak için kullanılabilecek birçok model var , ancak hiçbirinin iyi bir çözümü yok gibi görünüyor:

1. Bu döngünün içini silmeyin, bunun yerine ana döngüden sonra işlediğiniz ayrı bir "Silme Listesi" tutun.

   Bu normalde iyi bir çözümdür, ancak benim durumumda, öğeyi gerçekten silmek için ana döngüden kodumun mantık akışını değiştirene kadar öğenin anında "bekleyerek" gitmesine ihtiyacım var.

2. Öğeyi silmek yerine, öğe üzerinde bir bayrak ayarlayın ve onu devre dışı olarak işaretleyin. Ardından listeyi temizlemek için desen 1'in işlevselliğini ekleyin.

   Bu , tüm ihtiyaçlarım için işe yarar, ancak bu, bir öğeye her erişildiğinde etkin olmayan bayrağı kontrol etmek için birçok kodun değiştirilmesi gerektiği anlamına gelir . Bu benim zevkime göre çok fazla idare.

3. Bir şekilde model 2'nin fikirlerini bir sınıfa dahil edin List<T>. Bu Süper Liste, etkin olmayan bayrağı, nesnelerin olaydan sonra silinmesini ele alacak ve ayrıca etkin olmayan olarak işaretlenen öğeleri numaralandırma tüketicilerine göstermeyecektir. Temel olarak, sadece 2. modelin (ve ardından 1. modelin) tüm fikirlerini kapsamaktadır.

   Bunun gibi bir sınıf var mı? Bunun için kodu olan var mı? Yoksa daha iyi bir yol var mı?

4. Bunun myIntCollection.ToArray()yerine erişimin myIntCollectionsorunu çözeceği ve döngü içinde silmeme izin vereceği söylendi .

   Bu bana kötü bir tasarım kalıbı gibi geliyor, yoksa sorun olabilir mi?

Detaylar:

• Liste birçok öğe içerecek ve sadece bazılarını kaldıracağım.

• Döngünün içinde, her türlü işlemi yapıyor olacağım, ekleyeceğim, çıkaracağım, bu yüzden çözümün oldukça genel olması gerekiyor.

• Silmem gereken öğe döngüdeki geçerli öğe olmayabilir . Örneğin, 30 maddelik bir döngünün 10. maddesinde olabilirim ve madde 6 ya da madde 26'yı kaldırmam gerekebilir. Bu nedenle, dizi içinde geriye doğru yürümek artık işe yaramayacak. ;Ö(

En iyi çözüm genellikle RemoveAll()yöntemi kullanmaktır :

myList.RemoveAll(x => x.SomeProp == "SomeValue");

Veya belirli öğelerin kaldırılmasına ihtiyacınız varsa :

MyListType[] elems = new[] { elem1, elem2 };
myList.RemoveAll(x => elems.Contains(x));

Bu, elbette döngünüzün yalnızca kaldırma amaçlı olduğunu varsayar. Eğer varsa bunu ek bir işleme gerek, o zaman en iyi yöntem bir kullanımı genellikle forya whileo zamandan beri bir sýralayýcý kullanmıyorsanız, döngü:

for (int i = myList.Count - 1; i >= 0; i--)
{
    // Do processing here, then...
    if (shouldRemoveCondition)
    {
        myList.RemoveAt(i);
    }
}

Geriye doğru gitmek, hiçbir öğeyi atlamamanızı sağlar.

Düzenlemeye Yanıt :

Görünüşe göre rastgele öğeleri kaldıracaksanız, en kolay yöntem, kaldırmak istediğiniz öğelerin kaydını tutmak ve ardından hepsini bir kerede kaldırmak olabilir. Bunun gibi bir şey:

List<int> toRemove = new List<int>();
foreach (var elem in myList)
{
    // Do some stuff

    // Check for removal
    if (needToRemoveAnElement)
    {
        toRemove.Add(elem);
    }
}

// Remove everything here
myList.RemoveAll(x => toRemove.Contains(x));

Hem a'yı numaralandırmanız hem de List<T>ondan çıkarmanız gerekiyorsa, o zaman basitçe a whileyerine bir döngü kullanmanızı öneririm .foreach

var index = 0;
while (index < myList.Count) {
  if (someCondition(myList[index])) {
    myList.RemoveAt(index);
  } else {
    index++;
  }
}

Bu gönderinin eski olduğunu biliyorum ama benim için işe yarayan şeyleri paylaşacağımı düşündüm.

Numaralandırma için listenin bir kopyasını oluşturun ve ardından her döngü için kopyalanan değerleri işleyebilir ve kaynak listesiyle kaldır / ekle / ne varsa kaldırabilirsiniz.

private void ProcessAndRemove(IList<Item> list)
{
    foreach (var item in list.ToList())
    {
        if (item.DeterminingFactor > 10)
        {
            list.Remove(item);
        }
    }
}

Bir listeyi yinelemeniz gerektiğinde ve döngü sırasında onu değiştirmeniz gerektiğinde, bir for döngüsü kullanmanız daha iyi olur:

for (int i = 0; i < myIntCollection.Count; i++)
{
    if (myIntCollection[i] == 42)
    {
        myIntCollection.Remove(i);
        i--;
    }
}

Tabii ki dikkatli olmalısınız, örneğin ibir öğe kaldırıldığında azaltıyorum, aksi takdirde girişleri atlayacağız (bir alternatif listeden geriye gitmektir).

Eğer Linq varsa o zaman sadece kullanmalısınız RemoveAlldlev önerdi olarak.

Listeyi numaralandırırken, SAKLAMAK istediğinizi yeni bir listeye ekleyin. Daha sonra, yeni listeyimyIntCollection

List<int> myIntCollection=new List<int>();
myIntCollection.Add(42);
List<int> newCollection=new List<int>(myIntCollection.Count);

foreach(int i in myIntCollection)
{
    if (i want to delete this)
        ///
    else
        newCollection.Add(i);
}
myIntCollection = newCollection;

Size kodu ekleyelim:

List<int> myIntCollection=new List<int>();
myIntCollection.Add(42);
myIntCollection.Add(12);
myIntCollection.Add(96);
myIntCollection.Add(25);

Bir foreach'teyken listeyi değiştirmek isterseniz, yazmalısınız .ToList()

foreach(int i in myIntCollection.ToList())
{
    if (i == 42)
       myIntCollection.Remove(96);
    if (i == 25)
       myIntCollection.Remove(42);
}

Yardımcı olabileceği için, yüklemle eşleşen öğeleri kaldırmak ve kaldırılan öğelerin listesini döndürmek için bu Uzantı yöntemini yazdım.

    public static IList<T> RemoveAllKeepRemoved<T>(this IList<T> source, Predicate<T> predicate)
    {
        IList<T> removed = new List<T>();
        for (int i = source.Count - 1; i >= 0; i--)
        {
            T item = source[i];
            if (predicate(item))
            {
                removed.Add(item);
                source.RemoveAt(i);
            }
        }
        return removed;
    }

Ne dersin

int[] tmp = new int[myIntCollection.Count ()];
myIntCollection.CopyTo(tmp);
foreach(int i in tmp)
{
    myIntCollection.Remove(42); //The error is no longer here.
}

Yüksek performansla ilgileniyorsanız, iki liste kullanabilirsiniz. Aşağıdakiler, çöp toplamayı en aza indirir, bellek yerelliğini en üst düzeye çıkarır ve bir öğeyi bir listeden asla çıkarmaz; bu, son öğe değilse çok verimsizdir.

private void RemoveItems()
{
    _newList.Clear();

    foreach (var item in _list)
    {
        item.Process();
        if (!item.NeedsRemoving())
            _newList.Add(item);
    }

    var swap = _list;
    _list = _newList;
    _newList = swap;
}

Sadece, işlerken bir listeden öğeleri kaldırmam gereken benzer bir soruna çözümümü paylaşacağımı düşündüm.

Yani temelde "foreach", öğeyi yinelendikten sonra listeden kaldıracaktır.

Benim testim:

var list = new List<TempLoopDto>();
list.Add(new TempLoopDto("Test1"));
list.Add(new TempLoopDto("Test2"));
list.Add(new TempLoopDto("Test3"));
list.Add(new TempLoopDto("Test4"));

list.PopForEach((item) =>
{
    Console.WriteLine($"Process {item.Name}");
});

Assert.That(list.Count, Is.EqualTo(0));

Bunu, bir eylem gerçekleştirecek ve ardından öğeyi listeden kaldıracak bir uzantı yöntemi "PopForEach" ile çözdüm.

public static class ListExtensions
{
    public static void PopForEach<T>(this List<T> list, Action<T> action)
    {
        var index = 0;
        while (index < list.Count) {
            action(list[index]);
            list.RemoveAt(index);
        }
    }
}

Umarım bu herhangi birine yardımcı olabilir.