ทำไมไม่มีวิธีการขยาย ForEach ใน IEnumerable?

แรงบันดาลใจจากคำถามอื่นที่ถามเกี่ยวกับZipฟังก์ชั่นที่หายไป:

เหตุใดจึงไม่มีForEachวิธีการขยายในEnumerableชั้นเรียน หรือที่ไหนก็ได้? ชั้นเดียวที่ได้รับวิธีการคือForEach List<>มีเหตุผลว่าทำไมมันหายไป (การแสดง)?

มีคำสั่ง foreach รวมอยู่ในภาษาที่ทำงานได้เกือบตลอดเวลา

ฉันเกลียดที่จะเห็นสิ่งต่อไปนี้:

list.ForEach( item =>
{
    item.DoSomething();
} );

แทน:

foreach(Item item in list)
{
     item.DoSomething();
}

หลังมีความชัดเจนและง่ายต่อการอ่าน ในสถานการณ์ส่วนใหญ่แม้ว่าอาจจะพิมพ์ได้นานกว่าก็ตาม

อย่างไรก็ตามฉันต้องยอมรับว่าฉันเปลี่ยนท่าทางในเรื่องนั้น; วิธีการขยาย ForEach () จะมีประโยชน์ในบางสถานการณ์

นี่คือความแตกต่างที่สำคัญระหว่างคำสั่งและวิธีการ:

• การตรวจสอบประเภท: foreach ทำที่รันไทม์, ForEach () เป็นเวลารวบรวม (Big Plus!)
• ไวยากรณ์ที่ใช้เรียกผู้รับมอบสิทธิ์นั้นง่ายกว่ามาก ๆ : objects.ForEach (DoSomething);
• ForEach () สามารถถูกล่ามโซ่: แม้ว่าความชั่วร้าย / ประโยชน์ของคุณลักษณะดังกล่าวจะเปิดให้มีการอภิปราย

นี่เป็นจุดที่ยอดเยี่ยมที่ทำโดยคนจำนวนมากที่นี่และฉันเห็นได้ว่าทำไมคนถึงขาดฟังก์ชั่น ฉันไม่รังเกียจที่ Microsoft จะเพิ่มวิธีมาตรฐาน ForEach ในการทำซ้ำเฟรมเวิร์กถัดไป

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

อย่างไรก็ตามหากคุณพลาดฟังก์ชั่นเล็ก ๆ น้อย ๆ ที่ดีจริงๆคุณสามารถแผ่ออกเวอร์ชั่นของคุณเอง

public static void ForEach<T>(
    this IEnumerable<T> source,
    Action<T> action)
{
    foreach (T element in source) 
        action(element);
}

คุณสามารถเขียนวิธีการขยายนี้:

// Possibly call this "Do"
IEnumerable<T> Apply<T> (this IEnumerable<T> source, Action<T> action)
{
    foreach (var e in source)
    {
        action(e);
        yield return e;
    }
}

ข้อดี

อนุญาตให้ผูกมัด:

MySequence
    .Apply(...)
    .Apply(...)
    .Apply(...);

จุดด้อย

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

// possibly call this "Realize"
IEnumerable<T> Done<T> (this IEnumerable<T> source)
{
    foreach (var e in source)
    {
        // do nothing
        ;
    }

    return source;
}

นี่อาจมีความสำคัญมากเกินไปที่จะออกเดินทางจากไลบรารี่การจัดส่ง C #; ผู้อ่านที่ไม่คุ้นเคยกับวิธีการขยายของคุณจะไม่รู้ว่าจะทำอย่างไรกับโค้ดของคุณ

การสนทนาที่นี่ให้คำตอบ:

ที่จริงแล้วการสนทนาเฉพาะที่ฉันเห็นในความเป็นจริงนั้นเหนือกว่าความบริสุทธิ์ตามหน้าที่ ในการแสดงออกมีข้อสมมติฐานบ่อยครั้งเกี่ยวกับการไม่มีผลข้างเคียง การมี ForEach เป็นการเชิญชวนให้เกิดผลข้างเคียงโดยเฉพาะมากกว่าที่จะทนกับพวกเขา - Keith Farmer (หุ้นส่วน)

โดยทั่วไปการตัดสินใจที่จะทำให้วิธีการขยายฟังก์ชั่น "บริสุทธิ์" ForEach จะสนับสนุนให้เกิดผลข้างเคียงเมื่อใช้วิธีการขยาย Enumerable ซึ่งไม่ได้มีเจตนา

ในขณะที่ฉันตกลงว่าจะดีกว่าที่จะใช้โครงสร้างที่มีอยู่แล้วforeachในกรณีส่วนใหญ่ฉันพบว่าการใช้รูปแบบนี้ในส่วนขยาย ForEach <> นั้นดีกว่าการจัดการดัชนีในแบบปกติforeach:

public static int ForEach<T>(this IEnumerable<T> list, Action<int, T> action)
{
    if (action == null) throw new ArgumentNullException("action");

    var index = 0;

    foreach (var elem in list)
        action(index++, elem);

    return index;
}

var people = new[] { "Moe", "Curly", "Larry" };
people.ForEach((i, p) => Console.WriteLine("Person #{0} is {1}", i, p));

จะให้คุณ:

Person #0 is Moe
Person #1 is Curly
Person #2 is Larry

.ToList().ForEach(x => ...)หนึ่งวิธีแก้ปัญหาคือการเขียน

ข้อดี

ง่ายต่อการเข้าใจ - ผู้อ่านจำเป็นต้องรู้ว่าอะไรที่มาพร้อมกับ C # ไม่ใช่วิธีการขยายเพิ่มเติมใด ๆ

เสียงของวากยสัมพันธ์นั้นอ่อนมาก (เพิ่มรหัส extranious เล็กน้อย)

มักจะไม่เสียค่าใช้จ่ายหน่วยความจำเพิ่มเติมเนื่องจากคนพื้นเมือง.ForEach()จะต้องตระหนักถึงการสะสมทั้งหมดแล้ว

ข้อเสีย

คำสั่งของการดำเนินการไม่เหมาะ ฉันควรตระหนักถึงองค์ประกอบหนึ่งแล้วดำเนินการกับมันแล้วทำซ้ำ รหัสนี้ตระหนักถึงองค์ประกอบทั้งหมดก่อนจากนั้นจึงดำเนินการตามลำดับ

หากการรับรู้รายการเกิดข้อผิดพลาดคุณจะไม่มีวันทำอะไรกับองค์ประกอบเดี่ยว

หากการแจงนับไม่มีที่สิ้นสุด (เช่นจำนวนธรรมชาติ) แสดงว่าคุณไม่มีโชค

ฉันสงสัยอยู่เสมอว่าตัวเองนั่นคือเหตุผลที่ฉันพกติดตัวไปด้วย:

public static void ForEach<T>(this IEnumerable<T> col, Action<T> action)
{
    if (action == null)
    {
        throw new ArgumentNullException("action");
    }
    foreach (var item in col)
    {
        action(item);
    }
}

วิธีการขยายเล็กน้อยดี

ดังนั้นจึงมีความคิดเห็นมากมายเกี่ยวกับความจริงที่ว่าวิธีการส่วนขยาย ForEach นั้นไม่เหมาะสมเพราะมันจะไม่ส่งกลับค่าเช่นวิธีการขยาย LINQ แม้ว่านี่จะเป็นข้อความจริง แต่ก็ไม่เป็นความจริงทั้งหมด

เมธอดส่วนขยาย LINQ จะส่งคืนค่าทั้งหมดเพื่อให้สามารถโยงกันได้:

collection.Where(i => i.Name = "hello").Select(i => i.FullName);

อย่างไรก็ตามเพียงเพราะ LINQ ถูกนำมาใช้โดยใช้วิธีการขยายไม่ได้หมายความว่าวิธีการขยายต้องใช้ในวิธีเดียวกันและส่งคืนค่า การเขียนวิธีการขยายเพื่อแสดงฟังก์ชั่นทั่วไปที่ไม่ส่งคืนค่าเป็นการใช้งานที่สมบูรณ์แบบ

ข้อโต้แย้งเฉพาะเกี่ยวกับ ForEach นั้นขึ้นอยู่กับข้อ จำกัด ของวิธีการขยาย (นั่นคือวิธีการขยายจะไม่แทนที่วิธีการสืบทอดที่มีลายเซ็นเดียวกัน ) อาจมีสถานการณ์ที่วิธีการขยายแบบกำหนดเองพร้อมใช้งานในทุกชั้นเรียน IEnumerable <T> ยกเว้น List <T> สิ่งนี้อาจทำให้เกิดความสับสนเมื่อวิธีการเริ่มทำงานแตกต่างกันไปขึ้นอยู่กับว่าวิธีการขยายหรือวิธีการสืบทอดที่ถูกเรียกว่า

คุณสามารถใช้ (chainable แต่ประเมินอย่างเกียจคร้าน) Selectก่อนอื่นให้ดำเนินการของคุณจากนั้นส่งคืนตัวตน (หรืออย่างอื่นถ้าคุณต้องการ)

IEnumerable<string> people = new List<string>(){"alica", "bob", "john", "pete"};
people.Select(p => { Console.WriteLine(p); return p; });

คุณจะต้องตรวจสอบให้แน่ใจว่ายังคงได้รับการประเมินไม่ว่าจะด้วยCount()(การดำเนินการที่ถูกที่สุดในการระบุ afaik) หรือการดำเนินการอื่นที่คุณต้องการ

ฉันชอบที่จะเห็นมันเข้ามาในห้องสมุดมาตรฐานแม้ว่า:

static IEnumerable<T> WithLazySideEffect(this IEnumerable<T> src, Action<T> action) {
  return src.Select(i => { action(i); return i; } );
}

โค้ดข้างต้นจะกลายเป็นpeople.WithLazySideEffect(p => Console.WriteLine(p))ซึ่งเทียบเท่ากับ foreach ได้อย่างมีประสิทธิภาพ แต่ขี้เกียจและ chainable

โปรดทราบว่าMoreLINQ NuGet ให้ForEachวิธีการขยายที่คุณกำลังมองหา (เช่นเดียวกับPipeวิธีการที่ดำเนินการผู้รับมอบสิทธิ์และให้ผลลัพธ์ของมัน) ดู:

• https://www.nuget.org/packages/morelinq
• https://code.google.com/p/morelinq/wiki/OperatorsOverview

@Coincoin

พลังที่แท้จริงของวิธีการส่วนต่อ foreach เกี่ยวข้องกับการนำมาใช้ใหม่Action<>โดยไม่ต้องเพิ่มวิธีการที่ไม่จำเป็นในรหัสของคุณ สมมติว่าคุณมี 10 รายการและคุณต้องการดำเนินการตามตรรกะเดียวกันกับพวกเขาและฟังก์ชั่นที่เกี่ยวข้องไม่เหมาะกับชั้นเรียนของคุณและไม่ได้ใช้ซ้ำ แทนที่จะมีสิบลูปหรือฟังก์ชั่นทั่วไปที่เห็นได้ชัดว่าเป็นผู้ช่วยที่ไม่ได้เป็นของคุณสามารถเก็บตรรกะทั้งหมดของคุณไว้ในที่เดียว ( Action<>ดังนั้นดังนั้นหลายบรรทัดถูกแทนที่ด้วย

Action<blah,blah> f = { foo };

List1.ForEach(p => f(p))
List2.ForEach(p => f(p))

ฯลฯ ...

ตรรกะอยู่ในที่เดียวและคุณไม่ได้ทำให้ห้องเรียนของคุณสกปรก

เมธอดส่วนขยาย LINQ ส่วนใหญ่ส่งคืนผลลัพธ์ ForEach ไม่เหมาะกับรูปแบบนี้เนื่องจากไม่มีผลตอบแทนใด ๆ

หากคุณมี F # (ซึ่งจะอยู่ใน. NET เวอร์ชั่นถัดไป) คุณสามารถใช้

Seq.iter doSomething myIEnumerable

ส่วนหนึ่งเป็นเพราะผู้ออกแบบภาษาไม่เห็นด้วยกับมุมมองทางปรัชญา

• การไม่มี (และทดสอบ ... ) สถานที่ทำงานน้อยกว่าการมีสถานที่
• มันไม่ได้สั้นกว่าจริง ๆ (มีบางฟังก์ชันที่ผ่านกรณีที่มันอยู่ แต่นั่นไม่ใช่การใช้งานหลัก)
• มันมีวัตถุประสงค์เพื่อให้มีผลข้างเคียงซึ่งไม่ใช่สิ่งที่ linq เป็นเรื่องเกี่ยวกับ
• ทำไมมีวิธีอื่นในการทำสิ่งเดียวกันกับคุณลักษณะที่เรามีอยู่แล้ว (คำหลัก foreach)

https://blogs.msdn.microsoft.com/ericlippert/2009/05/18/foreach-vs-foreach/

คุณสามารถใช้การเลือกเมื่อคุณต้องการส่งคืนบางสิ่งบางอย่าง ถ้าคุณไม่ทำคุณสามารถใช้ ToList ก่อนเพราะคุณอาจไม่ต้องการแก้ไขอะไรในคอลเลกชัน

ฉันเขียนบทความในบล็อกเกี่ยวกับมัน: http://blogs.msdn.com/kirillosenkov/archive/2009/01/31/foreach.aspx

คุณสามารถลงคะแนนได้ที่นี่หากคุณต้องการดูวิธีการนี้ใน. NET 4.0: http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=279093

ใน 3.5 เมธอดส่วนขยายทั้งหมดที่เพิ่มใน IEnumerable จะมีไว้สำหรับการสนับสนุน LINQ (โปรดสังเกตว่ามีการกำหนดไว้ในคลาส System.Linq.Enumerable) ในโพสต์นี้ฉันอธิบายว่าทำไม foreach ไม่ได้อยู่ใน LINQ: วิธีการขยาย LINQ ที่มีอยู่คล้ายกับ Parallel.For?

เป็นฉันหรือเป็นรายการ <T> .Foreach ค่อนข้างล้าสมัยโดย Linq แต่เดิมมี

foreach(X x in Y) 

โดยที่ Y ต้องเป็น IEnumerable (Pre 2.0) และติดตั้ง GetEnumerator () ถ้าคุณดูที่ MSIL ที่สร้างขึ้นคุณจะเห็นได้ว่ามันเหมือนกับสิ่งเดียวกัน

IEnumerator<int> enumerator = list.GetEnumerator();
while (enumerator.MoveNext())
{
    int i = enumerator.Current;

    Console.WriteLine(i);
}

(ดูhttp://alski.net/post/0a-for-foreach-forFirst-forLast0a-0a-.aspxสำหรับ MSIL)

จากนั้นใน DotNet2.0 Generics จะเข้ามาพร้อมกับรายการ Foreach ให้ความสำคัญกับฉันเสมอในการใช้รูปแบบ Vistor (ดูรูปแบบการออกแบบโดย Gamma, Helm, Johnson, Vlissides)

ตอนนี้แน่นอนใน 3.5 เราสามารถใช้แลมบ์ดาแทนเอฟเฟกต์เดียวกันได้ตัวอย่างลอง http://dotnet-developments.blogs.techtarget.com/2008/09/02/iterators-lambda-and-linq-oh- ฉัน /

ฉันต้องการที่จะขยายตัวในคำตอบของคุ

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

private static IEnumerable<T> ForEach<T>(IEnumerable<T> xs, Action<T> f) {
    foreach (var x in xs) {
        f(x); yield return x;
    }
}

ยังไม่มีใครชี้ให้เห็นว่า ForEach <T> ผลลัพธ์ในการตรวจสอบประเภทเวลาคอมไพล์โดยที่คำสำคัญ foreach คือการตรวจสอบรันไทม์

หลังจากทำการปรับเปลี่ยนบางอย่างโดยใช้ทั้งสองวิธีในโค้ดฉันชอบ. ForEach เนื่องจากฉันต้องค้นหาความล้มเหลวในการทดสอบ / ความล้มเหลวรันไทม์เพื่อค้นหาปัญหา foreach