Найкращий спосіб видалити предмети з колекції

Який найкращий спосіб підійти до видалення елементів із колекції в C #, як тільки елемент стане відомим, але не його індексом. Це один із способів зробити це, але в кращому випадку це здається неелегантним.

//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);

Що б я насправді хотів зробити, це знайти елемент для видалення за властивістю (в даному випадку за назвою), не переглядаючи всю колекцію та використовуючи 2 додаткові змінні.

Якщо ви хочете отримати доступ до учасників колекції за одним із їх властивостей, ви можете замість цього використати Dictionary<T>або KeyedCollection<T>. Таким чином вам не доведеться шукати предмет, який ви шукаєте.

В іншому випадку ви можете принаймні зробити це:

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

Якщо RoleAssignments є a, List<T>ви можете використовувати наступний код.

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

@smaclell запитав, чому зворотна ітерація була більш ефективною в коментарі @ sambo99.

Іноді це ефективніше. Вважайте, що у вас є список людей, і ви хочете видалити або відфільтрувати всіх клієнтів з кредитним рейтингом <1000;

Ми маємо такі дані

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

Якби ми хотіли повторити вперед, то незабаром потрапимо в біду

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

При idx = 0 ми видаляємо Bob, що потім зміщує всі інші елементи вліво. Наступного разу через цикл idx = 1, але список [1] ​​тепер Tedзамість Mary. Ми в кінцевому підсумку пропускаємо Maryпомилково. Ми могли б використати цикл while, і ми могли б ввести більше змінних.

Або ми просто повертаємо ітерацію назад:

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

Усі індекси зліва від вилученого елемента залишаються однаковими, тому ви не пропускаєте жодних елементів.

Той самий принцип застосовується, якщо вам надано список індексів для видалення з масиву. Для того, щоб все було прямо, потрібно відсортувати список, а потім видалити елементи з найвищого індексу на найнижчий.

Тепер ви можете просто використовувати Linq і прямо заявляти про те, що робите.

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

У цьому випадку вилучення одного елемента не є більш ефективним ітерацією вперед або назад. Ви також можете використовувати Linq для цього.

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

Якщо це ICollectionтоді, у вас не буде RemoveAllметоду. Ось метод розширення, який це зробить:

    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));
    }

Засновано на: http://phejndorf.wordpress.com/2011/03/09/a-removeall-extension-for-the-collection-class/

Для простої структури списку найефективнішим способом видається використання реалізації Predicate RemoveAll.

Напр.

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

Причини:

1. Метод Predicate / Linq RemoveAll реалізований у списку та має доступ до внутрішнього масиву, що зберігає фактичні дані. Це змістить дані та змінить розмір внутрішнього масиву.
2. Реалізація методу RemoveAt відбувається досить повільно і копіює весь базовий масив даних у новий масив. Це означає, що зворотна ітерація марна для Списку

Якщо ви застрягли впровадити це в епоху до c # 3.0. У вас є 2 варіанти.

• Легко підтримуваний варіант. Скопіюйте всі відповідні елементи в новий список і поміняйте місцями основний список.

Напр.

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

Або

• Хитрий дещо швидший варіант, який передбачає зміщення всіх даних у списку вниз, коли вони не відповідають, а потім зміна розміру масиву.

Якщо ви дійсно часто видаляєте речі зі списку, можливо, для цієї мети краще підійде інша структура, така як HashTable (.net 1.1) або Словник (.net 2.0) або HashSet (.net 3.5).

Який тип колекції? Якщо це список, ви можете скористатися корисним "RemoveAll":

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

(Це працює в .NET 2.0. Звичайно, якщо у вас немає нового компілятора, вам доведеться використовувати "делегат (SPRoleAssignment spa) {return spa.Member.Name == shortName;}" замість nice синтаксис лямбда.)

Інший підхід, якщо це не Список, а все ж ICollection:

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

Для цього потрібні методи розширення Enumerable. (Ви можете скопіювати монофонічні файли, якщо ви застрягли на .NET 2.0). Якщо це якась спеціальна колекція, яка не може взяти предмет, але ПОВИННА взяти індекс, деякі інші методи Enumerable, такі як Select, передають цілий індекс для вас.

Це моє загальне рішення

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();
    }

Виглядало б набагато простіше, якби методи розширення підтримували передачу за посиланням! використання:

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

РЕДАГУВАТИ: забезпечено, щоб цикл списку залишався чинним навіть під час видалення елементів шляхом зменшення індексу (idx).

Ось досить хороший спосіб це зробити

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();

Існує інший підхід, який ви можете застосувати залежно від того, як ви використовуєте свою колекцію. Якщо ви завантажуєте завдання один раз (наприклад, під час запуску програми), ви можете перекласти колекцію на льоту в хеш-таблицю, де:

коротке ім'я => SPRoleAssignment

Якщо ви зробите це, тоді, коли ви хочете видалити елемент із коротким ім'ям, все, що вам потрібно зробити, це видалити елемент з хеш-таблиці за допомогою ключа.

На жаль, якщо ви багато завантажуєте ці SPRoleAssignments, це, очевидно, не буде більш економічно ефективним з точки зору часу. Пропозиції інших людей щодо використання Linq були б непоганими, якщо ви використовуєте нову версію .NET Framework, але в іншому випадку вам доведеться дотримуватися методу, який ви використовуєте.

Подібно до точки зору Збірника словників, я зробив це.

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);
}

Примітка: Вищезазначений код не вдасться отримати в .Net Client Profile (3.5 та 4.5). Також деякі глядачі згадали, що він не працює в .Net4.0, а також не впевнені, які налаштування викликають проблему.

Тож замініть на код нижче .ToList () для оператора Where, щоб уникнути цієї помилки. «Колекція була змінена; операція перерахування може не виконуватися. "

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

За MSDN, починаючи з .Net4.5, профіль клієнта припиняється. http://msdn.microsoft.com/en-us/library/cc656912(v=vs.110).aspx

Спочатку збережіть свої предмети, а потім видаліть їх.

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

Вам потрібно замінити GetHashCode()у своєму класі Item.

Найкращий спосіб це зробити, використовуючи linq.

Приклад класу:

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

Запит Linq:

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

Цей запит видалить усі елементи, collection1якщо вони Nameвідповідають будь-яким елементам Nameзcollection2

Не забувайте використовувати: using System.Linq;

Щоб зробити це, переглядаючи колекцію, а не отримуючи модифікацію винятку колекції, такий підхід я застосовував раніше (зверніть увагу на .ToList () в кінці оригінальної колекції, це створює іншу колекцію в пам'яті , тоді ви можете змінити існуючу колекцію)

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

Якщо у вас є List<T>, тоді List<T>.RemoveAllце найкращий вибір. Не може бути нічого ефективнішого. Внутрішньо це робить масив, що рухається одним пострілом, не кажучи вже про те, що це O (N).

Якщо все, що у вас є, це IList<T>або приблизно, ICollection<T>ви отримали приблизно ці три варіанти:

    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);
            }
        }
    }

або

    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);
        }
    }

або

    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);
        }
    }

Виберіть або 1, або 2.

1 легше в пам’яті і швидше, якщо у вас є менше видалень (тобто предикат більшість разів хибний).

2 швидше, якщо у вас є більше видалень.

3 - найчистіший код, але погано працює з IMO. Знову ж все, що залежить від вхідних даних.

Деякі деталі порівняльного порівняння див. Https://github.com/dotnet/BenchmarkDotNet/issues/1505

Тут багато хороших відповідей; Мені особливо подобаються лямбда-вирази ... дуже чисті. Однак я був знедолений, не вказавши тип колекції. Це SPRoleAssignmentCollection (від MOSS), який має лише Remove (int) та Remove (SPPrincipal), а не зручний RemoveAll (). Отже, я зупинився на цьому, якщо немає кращої пропозиції.

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