Làm thế nào để loại bỏ các yếu tố khỏi một danh sách chung trong khi lặp qua nó?

Tôi đang tìm kiếm một mô hình tốt hơn để làm việc với một danh sách các yếu tố mà mỗi nhu cầu được xử lý và sau đó tùy thuộc vào kết quả sẽ bị xóa khỏi danh sách.

Bạn không thể sử dụng .Remove(element)bên trong foreach (var element in X)(vì nó dẫn đến Collection was modified; enumeration operation may not execute.ngoại lệ) ... bạn cũng không thể sử dụng for (int i = 0; i < elements.Count(); i++)và .RemoveAt(i)vì nó phá vỡ vị trí hiện tại của bạn trong bộ sưu tập so với i.

Có một cách thanh lịch để làm điều này?

Lặp lại danh sách của bạn ngược lại với một vòng lặp for:

for (int i = safePendingList.Count - 1; i >= 0; i--)
{
    // some code
    // safePendingList.RemoveAt(i);
}

Thí dụ:

var list = new List<int>(Enumerable.Range(1, 10));
for (int i = list.Count - 1; i >= 0; i--)
{
    if (list[i] > 5)
        list.RemoveAt(i);
}
list.ForEach(i => Console.WriteLine(i));

Thay phiên, bạn có thể sử dụng phương thức RemoveAll với một vị từ để kiểm tra lại:

safePendingList.RemoveAll(item => item.Value == someValue);

Đây là một ví dụ đơn giản để chứng minh:

var list = new List<int>(Enumerable.Range(1, 10));
Console.WriteLine("Before:");
list.ForEach(i => Console.WriteLine(i));
list.RemoveAll(i => i > 5);
Console.WriteLine("After:");
list.ForEach(i => Console.WriteLine(i));

Một giải pháp đơn giản và dễ hiểu:

Sử dụng một vòng lặp for tiêu chuẩn chạy ngược trên bộ sưu tập của bạn và RemoveAt(i)để loại bỏ các yếu tố.

Lặp lại ngược lại là điều đầu tiên bạn nghĩ đến khi bạn muốn xóa các thành phần khỏi Bộ sưu tập trong khi lặp lại nó.

May mắn thay, có một giải pháp thanh lịch hơn là viết một vòng lặp for liên quan đến việc gõ không cần thiết và có thể dễ bị lỗi.

ICollection<int> test = new List<int>(new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10});

foreach (int myInt in test.Reverse<int>())
{
    if (myInt % 2 == 0)
    {
        test.Remove(myInt);
    }
}

 foreach (var item in list.ToList()) {
     list.Remove(item);
 }

Nếu bạn thêm ".ToList ()" vào danh sách của mình (hoặc kết quả của truy vấn LINQ), bạn có thể xóa "mục" trực tiếp khỏi "danh sách" mà không bị " Bộ sưu tập đã sửa đổi, thao tác liệt kê có thể không thực thi ." lỗi. Trình biên dịch tạo một bản sao của "danh sách", để bạn có thể thực hiện xóa một cách an toàn trên mảng.

Mặc dù mẫu này không siêu hiệu quả, nhưng nó có cảm giác tự nhiên và đủ linh hoạt cho hầu hết mọi tình huống . Chẳng hạn như khi bạn muốn lưu từng "mục" vào DB và xóa nó khỏi danh sách chỉ khi lưu DB thành công.

Chọn các yếu tố bạn làm muốn chứ không phải cố gắng để loại bỏ các yếu tố mà bạn không muốn. Điều này dễ dàng hơn nhiều (và nói chung cũng hiệu quả hơn) so với việc loại bỏ các yếu tố.

var newSequence = (from el in list
                   where el.Something || el.AnotherThing < 0
                   select el);

Tôi muốn đăng bài này dưới dạng một bình luận để đáp lại bình luận mà Michael Dillon để lại bên dưới, nhưng nó quá dài và có lẽ hữu ích trong câu trả lời của tôi.

Cá nhân, tôi sẽ không bao giờ xóa từng mục một, nếu bạn cần loại bỏ, sau đó gọi RemoveAllđó là một vị từ và chỉ sắp xếp lại mảng bên trong một lần, trong khi Removethực hiện Array.Copythao tác cho mọi phần tử bạn xóa. RemoveAlllà hiệu quả hơn nhiều.

Và khi bạn quay ngược lại một danh sách, bạn đã có chỉ mục của phần tử bạn muốn xóa, vì vậy sẽ hiệu quả hơn rất nhiều khi gọi RemoveAt, vì Removetrước tiên hãy duyệt qua danh sách để tìm chỉ mục của phần tử bạn Tôi đang cố xóa, nhưng bạn đã biết chỉ số đó.

Vì vậy, tất cả, tôi không thấy bất kỳ lý do nào để gọi Removemột vòng lặp for. Và lý tưởng nhất là nếu có thể, hãy sử dụng đoạn mã trên để truyền các phần tử từ danh sách khi cần để không có cấu trúc dữ liệu thứ hai nào được tạo ra.

Sử dụng ToArray () trên danh sách chung cho phép bạn thực hiện Xóa (mục) trên Danh sách chung:

        List<String> strings = new List<string>() { "a", "b", "c", "d" };
        foreach (string s in strings.ToArray())
        {
            if (s == "b")
                strings.Remove(s);
        }

Sử dụng .ToList () sẽ tạo một bản sao danh sách của bạn, như được giải thích trong câu hỏi này: ToList () - Nó có tạo Danh sách mới không?

Bằng cách sử dụng ToList (), bạn có thể xóa khỏi danh sách ban đầu của mình, vì bạn thực sự đang lặp lại một bản sao.

foreach (var item in listTracked.ToList()) {    

        if (DetermineIfRequiresRemoval(item)) {
            listTracked.Remove(item)
        }

     }

Nếu chức năng xác định mục nào cần xóa không có tác dụng phụ và không làm biến đổi mục (đó là chức năng thuần túy), thì giải pháp đơn giản và hiệu quả (thời gian tuyến tính) là:

list.RemoveAll(condition);

Nếu có tác dụng phụ, tôi sẽ sử dụng một cái gì đó như:

var toRemove = new HashSet<T>();
foreach(var item in items)
{
     ...
     if(condition)
          toRemove.Add(item);
}
items.RemoveAll(toRemove.Contains);

Đây vẫn là thời gian tuyến tính, giả sử băm là tốt. Nhưng nó có việc sử dụng bộ nhớ tăng lên do hàm băm.

Cuối cùng, nếu danh sách của bạn chỉ là một IList<T>thay vì List<T>tôi đề nghị câu trả lời của tôi về Làm thế nào tôi có thể thực hiện trình lặp foreach đặc biệt này? . Điều này sẽ có thời gian chạy tuyến tính với các triển khai điển hình IList<T>, so với thời gian chạy bậc hai của nhiều câu trả lời khác.

Vì bất kỳ loại bỏ được thực hiện trên một điều kiện bạn có thể sử dụng

list.RemoveAll(item => item.Value == someValue);

List<T> TheList = new List<T>();

TheList.FindAll(element => element.Satisfies(Condition)).ForEach(element => TheList.Remove(element));

Bạn không thể sử dụng foreach, nhưng bạn có thể lặp đi lặp lại và quản lý biến chỉ số vòng lặp của bạn khi bạn xóa một mục, như vậy:

for (int i = 0; i < elements.Count; i++)
{
    if (<condition>)
    {
        // Decrement the loop counter to iterate this index again, since later elements will get moved down during the remove operation.
        elements.RemoveAt(i--);
    }
}

Lưu ý rằng nói chung tất cả các kỹ thuật này dựa trên hành vi của bộ sưu tập được lặp đi lặp lại. Kỹ thuật hiển thị ở đây sẽ hoạt động với Danh sách chuẩn (T). (Đó là hoàn toàn có thể viết lớp bộ sưu tập của riêng bạn và iterator rằng không cho phép xóa mục trong một vòng lặp foreach.)

Việc sử dụng Removehoặc RemoveAtvào một danh sách trong khi lặp lại danh sách đó đã cố tình gây khó khăn, bởi vì nó hầu như luôn luôn là điều sai trái . Bạn có thể có thể làm cho nó hoạt động với một số mẹo thông minh, nhưng nó sẽ cực kỳ chậm. Mỗi lần bạn gọi Removenó phải quét toàn bộ danh sách để tìm phần tử bạn muốn xóa. Mỗi lần bạn gọi RemoveAtnó phải di chuyển các phần tử tiếp theo 1 sang trái. Như vậy, bất kỳ giải pháp nào sử dụng Removehoặc RemoveAt, sẽ yêu cầu thời gian bậc hai, O (n²) .

Sử dụng RemoveAllnếu bạn có thể. Mặt khác, mẫu sau sẽ lọc danh sách tại chỗ theo thời gian tuyến tính, O (n) .

// Create a list to be filtered
IList<int> elements = new List<int>(new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
// Filter the list
int kept = 0;
for (int i = 0; i < elements.Count; i++) {
    // Test whether this is an element that we want to keep.
    if (elements[i] % 3 > 0) {
        // Add it to the list of kept elements.
        elements[kept] = elements[i];
        kept++;
    }
}
// Unfortunately IList has no Resize method. So instead we
// remove the last element of the list until: elements.Count == kept.
while (kept < elements.Count) elements.RemoveAt(elements.Count-1);

Tôi muốn "mẫu" là một cái gì đó như thế này:

foreach( thing in thingpile )
{
    if( /* condition#1 */ )
    {
        foreach.markfordeleting( thing );
    }
    elseif( /* condition#2 */ )
    {
        foreach.markforkeeping( thing );
    }
} 
foreachcompleted
{
    // then the programmer's choices would be:

    // delete everything that was marked for deleting
    foreach.deletenow(thingpile); 

    // ...or... keep only things that were marked for keeping
    foreach.keepnow(thingpile);

    // ...or even... make a new list of the unmarked items
    others = foreach.unmarked(thingpile);   
}

Điều này sẽ căn chỉnh mã với quá trình diễn ra trong não của lập trình viên.

Bằng cách giả sử rằng vị từ là thuộc tính Boolean của một phần tử, nếu nó đúng, thì phần tử này sẽ bị xóa:

        int i = 0;
        while (i < list.Count())
        {
            if (list[i].predicate == true)
            {
                list.RemoveAt(i);
                continue;
            }
            i++;
        }

Tôi sẽ chỉ định lại danh sách từ truy vấn LINQ đã lọc ra các yếu tố bạn không muốn giữ.

list = list.Where(item => ...).ToList();

Trừ khi danh sách rất lớn, không có vấn đề hiệu suất đáng kể nào trong việc này.

Cách tốt nhất để xóa các mục khỏi danh sách trong khi lặp lại nó là sử dụng RemoveAll(). Nhưng mối quan tâm chính được viết bởi mọi người là họ phải làm một số điều phức tạp bên trong vòng lặp và / hoặc có các trường hợp so sánh phức tạp.

Giải pháp là vẫn sử dụng RemoveAll()nhưng sử dụng ký hiệu này:

var list = new List<int>(Enumerable.Range(1, 10));
list.RemoveAll(item => 
{
    // Do some complex operations here
    // Or even some operations on the items
    SomeFunction(item);
    // In the end return true if the item is to be removed. False otherwise
    return item > 5;
});

foreach(var item in list.ToList())

{

if(item.Delete) list.Remove(item);

}

Đơn giản chỉ cần tạo một danh sách hoàn toàn mới từ danh sách đầu tiên. Tôi nói "Dễ dàng" thay vì "Đúng" vì việc tạo một danh sách hoàn toàn mới có thể có giá cao hơn so với phương pháp trước đây (tôi không bận tâm với bất kỳ điểm chuẩn nào.) Tôi thường thích mẫu này, nó cũng có thể hữu ích trong việc khắc phục Linq-To-Thực thể hạn chế.

for(i = list.Count()-1;i>=0;i--)

{

item=list[i];

if (item.Delete) list.Remove(item);

}

Cách này quay vòng qua danh sách ngược với vòng lặp For cũ đơn giản. Làm điều này về phía trước có thể có vấn đề nếu kích thước của bộ sưu tập thay đổi, nhưng ngược lại phải luôn an toàn.

Sao chép danh sách bạn đang lặp đi lặp lại. Sau đó loại bỏ khỏi bản sao và liên kết bản gốc. Đi ngược lại là khó hiểu và không hoạt động tốt khi lặp song song.

var ids = new List<int> { 1, 2, 3, 4 };
var iterableIds = ids.ToList();

Parallel.ForEach(iterableIds, id =>
{
    ids.Remove(id);
});

Tôi sẽ làm như thế này

using System.IO;
using System;
using System.Collections.Generic;

class Author
    {
        public string Firstname;
        public string Lastname;
        public int no;
    }

class Program
{
    private static bool isEven(int i) 
    { 
        return ((i % 2) == 0); 
    } 

    static void Main()
    {    
        var authorsList = new List<Author>()
        {
            new Author{ Firstname = "Bob", Lastname = "Smith", no = 2 },
            new Author{ Firstname = "Fred", Lastname = "Jones", no = 3 },
            new Author{ Firstname = "Brian", Lastname = "Brains", no = 4 },
            new Author{ Firstname = "Billy", Lastname = "TheKid", no = 1 }
        };

        authorsList.RemoveAll(item => isEven(item.no));

        foreach(var auth in authorsList)
        {
            Console.WriteLine(auth.Firstname + " " + auth.Lastname);
        }
    }
}

ĐẦU RA

Fred Jones
Billy TheKid

Tôi thấy mình trong một tình huống tương tự khi tôi phải loại bỏ mọi yếu tố ^thứ n trong một cái cho trước List<T>.

for (int i = 0, j = 0, n = 3; i < list.Count; i++)
{
    if ((j + 1) % n == 0) //Check current iteration is at the nth interval
    {
        list.RemoveAt(i);
        j++; //This extra addition is necessary. Without it j will wrap
             //down to zero, which will throw off our index.
    }
    j++; //This will always advance the j counter
}

Chi phí loại bỏ một mặt hàng khỏi danh sách tỷ lệ thuận với số lượng mặt hàng sau mặt hàng cần loại bỏ. Trong trường hợp nửa đầu của các mục đủ điều kiện để xóa, mọi cách tiếp cận dựa trên việc xóa từng mục riêng lẻ sẽ phải thực hiện về các hoạt động sao chép mục N * 4, có thể rất tốn kém nếu danh sách lớn .

Cách tiếp cận nhanh hơn là quét qua danh sách để tìm mục đầu tiên cần xóa (nếu có), và sau đó từ đó chuyển tiếp từng bản sao từng mục nên được giữ lại tại vị trí của mục đó. Một khi điều này được thực hiện, nếu các mục R được giữ lại, các mục R đầu tiên trong danh sách sẽ là các mục R đó và tất cả các mục yêu cầu xóa sẽ ở cuối. Nếu các mục đó bị xóa theo thứ tự ngược lại, hệ thống sẽ không phải sao chép bất kỳ mục nào trong số chúng, vì vậy nếu danh sách có N mục trong đó các mục R, bao gồm tất cả các F đầu tiên, được giữ lại, thì sẽ cần phải sao chép các mục RF và thu nhỏ danh sách theo một lần NR. Tất cả thời gian tuyến tính.

Cách tiếp cận của tôi là trước tiên tôi tạo một danh sách các chỉ số cần xóa. Sau đó, tôi lặp qua các chỉ số và xóa các mục khỏi danh sách ban đầu. Cái này trông như thế này:

var messageList = ...;
// Restrict your list to certain criteria
var customMessageList = messageList.FindAll(m => m.UserId == someId);

if (customMessageList != null && customMessageList.Count > 0)
{
    // Create list with positions in origin list
    List<int> positionList = new List<int>();
    foreach (var message in customMessageList)
    {
        var position = messageList.FindIndex(m => m.MessageId == message.MessageId);
        if (position != -1)
            positionList.Add(position);
    }
    // To be able to remove the items in the origin list, we do it backwards
    // so that the order of indices stays the same
    positionList = positionList.OrderByDescending(p => p).ToList();
    foreach (var position in positionList)
    {
        messageList.RemoveAt(position);
    }
}

Trong C #, một cách dễ dàng là đánh dấu những cái bạn muốn xóa sau đó tạo một danh sách mới để lặp lại ...

foreach(var item in list.ToList()){if(item.Delete) list.Remove(item);}  

hoặc thậm chí đơn giản hơn sử dụng linq ....

list.RemoveAll(p=>p.Delete);

nhưng nó đáng để xem xét nếu các tác vụ hoặc luồng khác sẽ có quyền truy cập vào cùng một danh sách cùng lúc bạn đang bận gỡ bỏ và có thể sử dụng một Danh sách đồng thời thay thế.

Theo dõi các yếu tố được loại bỏ bằng một thuộc tính và loại bỏ tất cả chúng sau quá trình.

using System.Linq;

List<MyProperty> _Group = new List<MyProperty>();
// ... add elements

bool cond = true;
foreach (MyProperty currObj in _Group)
{
    if (cond) 
    {
        // SET - element can be deleted
        currObj.REMOVE_ME = true;
    }
}
// RESET
_Group.RemoveAll(r => r.REMOVE_ME);

Chỉ muốn thêm 2 xu của tôi vào đây trong trường hợp điều này có ích cho bất kỳ ai, tôi đã gặp vấn đề tương tự nhưng cần phải loại bỏ nhiều yếu tố khỏi danh sách mảng trong khi nó được lặp đi lặp lại. câu trả lời được nâng cao nhất đã làm điều đó cho tôi trong hầu hết các phần cho đến khi tôi gặp lỗi và nhận ra rằng chỉ mục lớn hơn kích thước của danh sách mảng trong một số trường hợp vì nhiều phần tử đã bị xóa nhưng chỉ mục của vòng lặp không giữ theo dõi đó. Tôi đã sửa lỗi này bằng một kiểm tra đơn giản:

ArrayList place_holder = new ArrayList();
place_holder.Add("1");
place_holder.Add("2");
place_holder.Add("3");
place_holder.Add("4");

for(int i = place_holder.Count-1; i>= 0; i--){
    if(i>= place_holder.Count){
        i = place_holder.Count-1; 
    }

// some method that removes multiple elements here
}

myList.RemoveAt(i--);

simples;