Как удалить список из List<List<T>> с SequenceEqual в C#

Чтобы удалить конкретный список из List<List<T>> в C# с помощью SequenceEqual, используйте метод RemoveAll с лямбда-предикатом: outerList.RemoveAll(inner => inner.SequenceEqual(targetList));. Это сравнит каждый вложенный список поэлементно и удалит все точные совпадения — быстро и без лишних циклов. Главная ошибка в вашем коде — опечатка list<List<T>> вместо list.RemoveAll(...), плюс Visual Studio не понимает контекст без using System.Linq.

Содержание

• [Правильный синтаксис для удаления {#correct-syntax}]
• [Почему возникает ошибка компиляции {#compilation-error}]
• [Полный пример кода {#full-example}]
• [Как работает SequenceEqual в предикате {#sequence-equal}]
• [Обработка дубликатов и альтернатив {#duplicates-alternatives}]
• Источники
• Заключение

Правильный синтаксис для удаления

Представьте: у вас есть коллекция списков, типа банковских транзакций или координат, и нужно стереть одну точную копию. RemoveAll — это ваш лучший друг здесь. Он проходит по всей List<List<T>>, проверяет условие и стирает совпадения на лету.

Код простой:

using System.Linq; // Обязательно для SequenceEqual!

List<List<int>> outerList = new List<List<int>>
{
 new List<int> {1, 2, 3},
 new List<int> {4, 5},
 new List<int> {1, 2, 3} // Дубликат для теста
};

List<int> target = new List<int> {1, 2, 3};

int removedCount = outerList.RemoveAll(inner => inner.SequenceEqual(target));

Console.WriteLine($"Удалено списков: {removedCount}"); // Вывод: 2
Console.WriteLine(outerList.Count); // Осталось 1

Видишь? Два идентичных списка улетели. SequenceEqual из LINQ смотрит на элементы по порядку, игнорируя ссылки — сравнивает значения. В одном из топовых ответов на Stack Overflow именно так и рекомендуют для List<List<int>>.

А если типы сложные, вроде строк или объектов? Работает, пока T реализует IEquatable<T> или переопределяет Equals.

Почему возникает ошибка компиляции

Ваша строка list<List<T>>.RemoveAll(i => i.SequenceEqual(list)); — классическая засада. Visual Studio ругается “i не принадлежит сюда”, потому что:

1. Опечатка в названии: list<List<T>> — это не метод, а попытка объявить тип. Должно быть list.RemoveAll(...), где list — ваша переменная типа List<List<T>>.

2. Нет using System.Linq;: SequenceEqual — extension-метод из LINQ. Без него компилятор слепой.

3. Контекст i: i — это параметр лямбды, IntelliSense путается, если типы неявные. Укажите явно: innerList => innerList.SequenceEqual(target).

Добавьте using, поправьте вызов — и ошибка уйдет. Я сам вляпывался в это на VS 2022, когда спешил с шаблонами. Здесь на SO разбирают похожий случай — работает идеально.

Полный пример кода

Давайте разберем реальный сценарий. Допустим, список покупок в корзине — каждый внутренний список это товары одного заказа.

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
 static void Main()
 {
 List<List<string>> cart = new List<List<string>>
 {
 new List<string> { "яблоко", "банан" },
 new List<string> { "молоко", "хлеб" },
 new List<string> { "яблоко", "банан" } // Точно такой же заказ
 };

 List<string> toRemove = new List<string> { "яблоко", "банан" };

 // Удаляем все совпадения
 int count = cart.RemoveAll(order => order.SequenceEqual(toRemove));
 
 Console.WriteLine($"Удалено заказов: {count}"); // 2
 foreach (var order in cart)
 {
 Console.WriteLine(string.Join(", ", order)); // Только молоко, хлеб
 }
 }
}

Запустите — увидите магию. Поддерживает любые T: int, string, custom классы (с Equals). Для массивов int[] то же самое, как в этом примере.

Что если список большой? RemoveAll эффективен, O(n * m), где m — длина внутреннего списка. Для миллионов — подумайте о HashSet, но это уже другая история.

Как работает SequenceEqual в предикате

SequenceEqual — не просто ==. Он:

• Итерирует оба IEnumerable параллельно.
• Проверяет Equals для каждого элемента.
• Возвращает true, если длины равны и все элементы совпадают.

В предикате RemoveAll это lambda возвращает bool для каждого элемента. RemoveAll собирает индексы для удаления и сдвигает список — безопасно, без foreach-ловушек.

Но! Для reference-типов без Equals сравнит ссылки, а не значения. Переопределите Equals/GetHashCode или используйте кастомный comparer:

outerList.RemoveAll(inner => inner.SequenceEqual(target, customComparer));

Подробно в SO — там еще примеры с байтами.

А если порядок не важен? Тогда set.SequenceEqual(other.OrderBy(x=>x)) — но это медленнее.

Обработка дубликатов и альтернатив

Дубликаты? RemoveAll удалит все. Хотите только первый? RemoveAt(outerList.FindIndex(...)).

Альтернативы, если SequenceEqual не катит:

• LINQ Where + ToList: outerList = outerList.Where(inner => !inner.SequenceEqual(target)).ToList(); — создает новую коллекцию, медленнее для больших списков.
• Цикл с RemoveAt: Рискованно, индексы сдвигаются. Не делайте.
• HashSet для быстрого поиска: Но списки не хэшируемы напрямую — сериализуйте в tuple или string.

Для сложных объектов кастомный IEqualityComparer, включая nested SequenceEqual.

В общем, RemoveAll + SequenceEqual — золотой стандарт для точного матчинга. DEV Community подтверждает: предикат оценивается для каждого элемента.

Источники

1. List<List> Remove method на Stack Overflow
2. Remove an array from list на Stack Overflow
3. How to remove list items comparing with another list на Stack Overflow
4. How to remove List from another List на Stack Overflow
5. How to remove an element of List<int[]> в C# на Stack Overflow
6. RemoveAll explanation на DEV Community

Заключение

Удалить список из List<List<T>> через SequenceEqual проще простого: RemoveAll с лямбдой — и готово, без багов с индексами. Главное — using Linq и правильный синтаксис, без опечаток вроде list<List<T>>. Это работает для любых T, удаляет все дубли, и производительно. Протестируйте на своем коде — сэкономите часы дебаггинга!