วิธีลบองค์ประกอบออกจากรายการทั่วไปในขณะที่วนซ้ำมัน?

ฉันกำลังมองหารูปแบบที่ดีกว่าสำหรับการทำงานกับรายการองค์ประกอบที่ต้องดำเนินการแต่ละรายการและจากนั้นผลลัพธ์จะถูกลบออกจากรายการ

คุณไม่สามารถใช้.Remove(element)ภายในforeach (var element in X)(เพราะมันจะส่งผลในCollection was modified; enumeration operation may not execute.ข้อยกเว้น) ... คุณยังไม่สามารถใช้for (int i = 0; i < elements.Count(); i++)และเพราะมันรบกวนตำแหน่งปัจจุบันของคุณในการเก็บรวบรวมเทียบกับ.RemoveAt(i)i

มีวิธีที่สง่างามในการทำเช่นนี้หรือไม่?

วนซ้ำรายการของคุณย้อนกลับด้วย for for loop:

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

ตัวอย่าง:

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

คุณสามารถใช้เมธอด RemoveAllพร้อมเพรดิเคตเพื่อทดสอบกับ:

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

นี่เป็นตัวอย่างง่าย ๆ ที่จะสาธิต:

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

ทางออกที่ง่ายและตรงไปตรงมา:

ใช้มาตรฐานสำหรับวงวนย้อนหลังในคอลเลกชันของคุณและRemoveAt(i)เพื่อลบองค์ประกอบ

การวนซ้ำแบบย้อนกลับควรเป็นสิ่งแรกที่คุณควรคำนึงถึงเมื่อคุณต้องการลบองค์ประกอบออกจากคอลเลกชันในขณะที่วนซ้ำ

โชคดีที่มีวิธีแก้ปัญหาที่สง่างามกว่าการเขียนลูป for ซึ่งเกี่ยวข้องกับการพิมพ์ที่ไม่จำเป็นและอาจเกิดข้อผิดพลาดได้ง่าย

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

หากคุณเพิ่ม ".ToList ()"ในรายการของคุณ (หรือผลลัพธ์ของการสืบค้น LINQ) คุณสามารถลบ "รายการ" โดยตรงจาก "รายการ" โดยไม่มี " คอลเลกชันที่น่ากลัว" ถูกแก้ไขการดำเนินการแจงนับอาจไม่ทำงาน " ความผิดพลาด คอมไพเลอร์สร้างสำเนาของ "รายการ" เพื่อให้คุณสามารถลบออกได้อย่างปลอดภัย

ในขณะที่รูปแบบนี้ไม่ได้มีประสิทธิภาพสุดก็มีความรู้สึกเป็นธรรมชาติและมีความยืดหยุ่นพอสำหรับเกือบทุกสถานการณ์ เช่นเมื่อคุณต้องการบันทึก "รายการ" แต่ละรายการลงในฐานข้อมูลและลบออกจากรายการเฉพาะเมื่อฐานข้อมูลบันทึกสำเร็จ

เลือกองค์ประกอบที่คุณไม่ต้องการมากกว่าการพยายามที่จะเอาองค์ประกอบที่คุณไม่ต้องการ สิ่งนี้ง่ายกว่ามาก (และโดยทั่วไปก็มีประสิทธิภาพมากกว่าด้วย) กว่าการลบองค์ประกอบ

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

ฉันต้องการโพสต์สิ่งนี้เป็นความคิดเห็นเพื่อตอบสนองต่อความคิดเห็นที่เหลือโดย Michael Dillon ด้านล่าง แต่มันยาวเกินไปและอาจมีประโยชน์ในการตอบคำถามของฉัน:

โดยส่วนตัวแล้วฉันจะไม่ลบรายการทีละรายการถ้าคุณต้องการลบออกแล้วเรียกRemoveAllว่าใช้เพรดิเคตและจัดเรียงอาร์เรย์ภายในใหม่เพียงครั้งเดียวในขณะที่RemoveการArray.Copyดำเนินการสำหรับทุกองค์ประกอบที่คุณลบออกRemoveAllมีประสิทธิภาพมากขึ้นอย่างมากมาย

และเมื่อคุณย้อนกลับไปซ้ำในรายการคุณมีดัชนีขององค์ประกอบที่คุณต้องการลบอยู่แล้วดังนั้นมันจะมีประสิทธิภาพมากกว่าในการโทรRemoveAtเพราะRemoveอันดับแรกคือการสำรวจเส้นทางของรายการเพื่อค้นหาดัชนีขององค์ประกอบที่คุณ กำลังพยายามลบ แต่คุณรู้อยู่แล้วว่าดัชนีนั้น

ดังนั้นโดยรวมแล้วฉันไม่เห็นเหตุผลใด ๆ ที่จะโทรRemoveหาความจริง และถ้าเป็นไปได้ให้ใช้โค้ดด้านบนเพื่อสตรีมองค์ประกอบจากรายการตามต้องการดังนั้นจึงไม่มีการสร้างโครงสร้างข้อมูลที่สองเลย

การใช้ ToArray () ในรายการทั่วไปช่วยให้คุณสามารถลบ (รายการ) ในรายการทั่วไปของคุณ:

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

การใช้. ToList () จะทำสำเนารายการของคุณดังที่อธิบายไว้ในคำถามนี้ ToList () - สร้างรายการใหม่หรือไม่

โดยใช้ ToList () คุณสามารถลบออกจากรายการเดิมของคุณเพราะคุณทำซ้ำจริง ๆ แล้วคัดลอก

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

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

     }

หากฟังก์ชั่นที่กำหนดว่ารายการที่จะลบไม่มีผลข้างเคียงและไม่กลายพันธุ์รายการ (เป็นฟังก์ชั่นแท้) โซลูชันที่เรียบง่ายและมีประสิทธิภาพ (เวลาเชิงเส้น) คือ:

list.RemoveAll(condition);

หากมีผลข้างเคียงฉันจะใช้สิ่งที่ชอบ:

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

นี่เป็นเวลาเชิงเส้นโดยสมมติว่าแฮชดี แต่มีหน่วยความจำเพิ่มขึ้นเนื่องจาก hashset ใช้

สุดท้ายหากรายการของคุณเป็นเพียงการIList<T>แทนList<T>ผมขอแนะนำให้คำตอบของฉันฉันจะทำเช่นนี้ iterator foreach พิเศษหรือไม่? . สิ่งนี้จะมีไทม์มิ่งเชิงเส้นเนื่องจากการใช้งานทั่วไปของIList<T>เมื่อเทียบกับรันไทม์กำลังสองของคำตอบอื่น ๆ

เนื่องจากการลบใด ๆ เกิดขึ้นในสภาพที่คุณสามารถใช้ได้

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

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

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

คุณไม่สามารถใช้ foreach ได้ แต่คุณสามารถทำซ้ำไปข้างหน้าและจัดการตัวแปรดัชนีลูปของคุณเมื่อคุณลบรายการออกเช่น:

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

โปรดทราบว่าโดยทั่วไปเทคนิคเหล่านี้ทั้งหมดขึ้นอยู่กับพฤติกรรมของคอลเลกชันที่ถูกทำซ้ำ เทคนิคที่แสดงที่นี่จะทำงานกับรายการมาตรฐาน (T) (มันค่อนข้างเป็นไปได้ที่จะเขียนระดับคอลเลกชันของคุณเองและ iterator ที่ไม่ให้การกำจัดรายการระหว่างห่วง foreach.)

การใช้RemoveหรือRemoveAtในรายการขณะ iterating กว่ารายการที่ได้รับการจงใจทำยากเพราะมันมักจะเป็นสิ่งที่ไม่ถูกต้องที่จะทำ คุณอาจสามารถทำให้มันทำงานได้ด้วยเล่ห์เหลี่ยมบางอย่าง แต่มันจะช้ามาก ทุกครั้งที่คุณโทรRemoveจะต้องสแกนรายการทั้งหมดเพื่อค้นหาองค์ประกอบที่คุณต้องการลบ ทุกครั้งที่คุณเรียกRemoveAtมันจะต้องย้ายองค์ประกอบที่ตามมา 1 ตำแหน่งไปทางซ้าย เช่นการแก้ปัญหาใด ๆ ที่ใช้RemoveหรือRemoveAtจะต้องใช้เวลากำลังสองO (n²)

ใช้RemoveAllถ้าคุณสามารถ มิฉะนั้นต่อไปนี้รูปแบบจะกรองรายการในสถานที่ในเส้นเวลา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);

ฉันหวังว่า "รูปแบบ" เป็นอะไรเช่นนี้:

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

สิ่งนี้จะจัดแนวโค้ดกับกระบวนการที่เกิดขึ้นในสมองของโปรแกรมเมอร์

โดยสมมติว่ากริยาเป็นที่พักแบบบูลขององค์ประกอบว่าถ้ามันเป็นความจริงแล้วองค์ประกอบที่ควรจะออก:

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

ฉันจะมอบหมายรายการจากแบบสอบถาม LINQ ที่กรององค์ประกอบที่คุณไม่ต้องการเก็บไว้

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

หากรายการมีขนาดใหญ่มากไม่ควรมีปัญหาประสิทธิภาพที่สำคัญในการทำเช่นนี้

วิธีที่ดีที่สุดในการลบรายการออกจากรายการในขณะที่วนซ้ำมันคือการใช้ RemoveAll()วิธีที่ดีที่สุดที่จะลบรายการจากรายการในขณะที่การทำซ้ำมากกว่านั้นคือการใช้งานแต่ข้อกังวลหลักที่เขียนโดยคนคือพวกเขาต้องทำสิ่งที่ซับซ้อนบางอย่างภายในวงและ / หรือมีกรณีเปรียบเทียบที่ซับซ้อน

การแก้ปัญหาคือยังคงใช้RemoveAll()แต่ใช้สัญกรณ์นี้:

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

}

เพียงสร้างรายการใหม่ทั้งหมดจากรายการแรก ฉันพูดว่า "ง่าย" แทนที่จะเป็น "ถูกต้อง" เนื่องจากการสร้างรายการใหม่ทั้งหมดอาจมาพร้อมกับประสิทธิภาพที่เหนือชั้นกว่าวิธีก่อนหน้านี้ (ฉันไม่ได้ใส่ใจกับการเปรียบเทียบใด ๆ ) โดยทั่วไปฉันชอบรูปแบบนี้ก็เป็นประโยชน์ในการเอาชนะ ข้อ จำกัด Linq-To-Entities

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

{

item=list[i];

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

}

วิธีนี้วนรอบรายการย้อนหลังด้วย For old แบบธรรมดา การส่งต่อนี้อาจเป็นปัญหาได้หากขนาดของคอลเลกชันเปลี่ยนแปลง แต่กลับควรมีความปลอดภัยเสมอ

คัดลอกรายการที่คุณกำลังทำซ้ำ จากนั้นลบออกจากการคัดลอกและ interate ต้นฉบับ การย้อนกลับทำให้เกิดความสับสนและทำงานได้ไม่ดีเมื่อวนซ้ำกัน

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

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

ฉันจะทำเช่นนี้

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

เอาท์พุท

Fred Jones
Billy TheKid

ผมพบว่าตัวเองอยู่ในสถานการณ์ที่คล้ายกันที่ฉันมีการลบทุก n ^THList<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
}

ค่าใช้จ่ายในการลบรายการออกจากรายการเป็นสัดส่วนกับจำนวนรายการที่จะถูกลบออก ในกรณีที่ครึ่งแรกของรายการมีคุณสมบัติสำหรับการลบวิธีการใด ๆ ที่ยึดตามการลบแต่ละรายการจะต้องดำเนินการเกี่ยวกับการคัดลอกรายการ N * N / 4 ซึ่งอาจมีราคาแพงมากหากรายการมีขนาดใหญ่ .

วิธีที่เร็วกว่าคือการสแกนผ่านรายการเพื่อค้นหารายการแรกที่จะลบ (ถ้ามี) จากนั้นไปที่จุดนั้นไปข้างหน้าคัดลอกแต่ละรายการที่ควรเก็บไว้ในจุดที่เป็นของมัน เมื่อดำเนินการเสร็จแล้วหากควรเก็บรักษารายการ R รายการ R แรกในรายการจะเป็นรายการ R เหล่านั้นและรายการทั้งหมดที่ต้องการลบจะอยู่ที่ท้าย หากมีการลบรายการเหล่านั้นในลำดับย้อนหลังระบบจะไม่ต้องคัดลอกรายการใด ๆ ดังนั้นหากรายการมีรายการ N รายการซึ่งรายการ R ซึ่งรวมถึง F แรกทั้งหมดถูกเก็บรักษาไว้จะต้อง คัดลอกรายการ RF และลดขนาดรายการด้วย NR รายการหนึ่งรายการ เวลาเชิงเส้นทั้งหมด

แนวทางของฉันคือฉันสร้างรายการดัชนีครั้งแรกซึ่งควรลบออก หลังจากนั้นฉันวนรอบดัชนีและลบรายการออกจากรายการเริ่มต้น ดูเหมือนว่านี้:

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

ในวิธีง่ายๆคือการทำเครื่องหมายรายการที่คุณต้องการลบจากนั้นสร้างรายการใหม่เพื่อทำซ้ำ ...

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

หรือแม้กระทั่งใช้ linq ที่ง่ายยิ่งขึ้น ....

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

แต่มันก็คุ้มค่าที่จะพิจารณาว่างานหรือกระทู้อื่น ๆ จะสามารถเข้าถึงรายการเดียวกันในเวลาเดียวกันกับที่คุณกำลังยุ่งอยู่กับการลบหรือไม่และอาจใช้ ConcurrentList แทน

ติดตามองค์ประกอบที่จะลบด้วยคุณสมบัติและลบออกหลังจากกระบวนการ

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

เพียงแค่ต้องการเพิ่ม 2 เซ็นต์ของฉันในกรณีนี้จะช่วยให้ทุกคนฉันมีปัญหาที่คล้ายกัน แต่จำเป็นต้องลบองค์ประกอบหลายรายการจากรายการอาร์เรย์ในขณะที่มันถูกทำซ้ำมากกว่า คำตอบ upvoted ที่สูงที่สุดทำเพื่อฉันจนกระทั่งส่วนใหญ่เกิดข้อผิดพลาดและรู้ว่าดัชนีนั้นมีขนาดใหญ่กว่าขนาดของรายการอาร์เรย์ในบางกรณีเนื่องจากมีการลบองค์ประกอบหลายรายการ แต่ดัชนีของวงไม่ได้เก็บไว้ ติดตามของที่ ฉันแก้ไขสิ่งนี้ด้วยการตรวจสอบง่าย ๆ :

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;