คืน enumerables ทั้งหมดพร้อมผลตอบแทนในทันที โดยไม่ต้องวนซ้ำผ่าน

ฉันมีฟังก์ชั่นต่อไปนี้เพื่อรับข้อผิดพลาดในการตรวจสอบความถูกต้องของการ์ด คำถามของฉันเกี่ยวข้องกับการจัดการกับ GetErrors IEnumerable<ErrorInfo>ทั้งสองวิธีมีผลตอบแทนประเภทเดียวกัน

private static IEnumerable<ErrorInfo> GetErrors(Card card)
{
    var errors = GetMoreErrors(card);
    foreach (var e in errors)
        yield return e;

    // further yield returns for more validation errors
}

เป็นไปได้ไหมที่จะส่งคืนข้อผิดพลาดทั้งหมดGetMoreErrorsโดยไม่ต้องแจงผ่านพวกเขา

คิดเกี่ยวกับมันอาจเป็นคำถามที่โง่ แต่ฉันต้องการให้แน่ใจว่าฉันจะไม่ผิด

ไม่ใช่คำถามที่โง่เง่าแน่นอนและมันเป็นสิ่งที่ F # ให้การสนับสนุนyield!สำหรับคอลเลกชันทั้งหมดเทียบyieldกับรายการเดียว (นั่นอาจมีประโยชน์มากในแง่ของการเรียกซ้ำหาง ... )

น่าเสียดายที่มันไม่รองรับใน C #

อย่างไรก็ตามหากคุณมีหลายวิธีในการส่งคืนIEnumerable<ErrorInfo>คุณสามารถใช้Enumerable.Concatเพื่อทำให้โค้ดของคุณง่ายขึ้น:

private static IEnumerable<ErrorInfo> GetErrors(Card card)
{
    return GetMoreErrors(card).Concat(GetOtherErrors())
                              .Concat(GetValidationErrors())
                              .Concat(AnyMoreErrors())
                              .Concat(ICantBelieveHowManyErrorsYouHave());
}

มีความแตกต่างที่สำคัญอย่างหนึ่งระหว่างการนำไปใช้งานสองอย่าง: วิธีนี้จะเรียกใช้วิธีการทั้งหมดทันทีแม้ว่าจะใช้ตัววนซ้ำที่ส่งกลับทีละครั้งเท่านั้น รหัสที่มีอยู่ของคุณจะรอจนกว่าจะวนซ้ำทุกอย่างGetMoreErrors()ก่อนที่จะถามถึงข้อผิดพลาดต่อไป

ปกติแล้วสิ่งนี้จะไม่สำคัญ แต่ควรทำความเข้าใจกับสิ่งที่จะเกิดขึ้นเมื่อใด

คุณสามารถตั้งค่าแหล่งที่มาของข้อผิดพลาดทั้งหมดเช่นนี้ (ชื่อวิธีการยืมจากคำตอบของ Jon Skeet)

private static IEnumerable<IEnumerable<ErrorInfo>> GetErrorSources(Card card)
{
    yield return GetMoreErrors(card);
    yield return GetOtherErrors();
    yield return GetValidationErrors();
    yield return AnyMoreErrors();
    yield return ICantBelieveHowManyErrorsYouHave();
}

จากนั้นคุณสามารถทำซ้ำได้ในเวลาเดียวกัน

private static IEnumerable<ErrorInfo> GetErrors(Card card)
{
    foreach (var errorSource in GetErrorSources(card))
        foreach (var error in errorSource)
            yield return error;
}

SelectManyหรือคุณสามารถแผ่แหล่งข้อผิดพลาดด้วย

private static IEnumerable<ErrorInfo> GetErrors(Card card)
{
    return GetErrorSources(card).SelectMany(e => e);
}

การดำเนินการของวิธีการในGetErrorSourcesจะล่าช้าเกินไป

ฉันพบyield_ข้อมูลโค้ดสั้น ๆ :

นี่คือตัวอย่าง XML:

<?xml version="1.0" encoding="utf-8"?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Author>John Gietzen</Author>
      <Description>yield! expansion for C#</Description>
      <Shortcut>yield_</Shortcut>
      <Title>Yield All</Title>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
    </Header>
    <Snippet>
      <Declarations>
        <Literal Editable="true">
          <Default>items</Default>
          <ID>items</ID>
        </Literal>
        <Literal Editable="true">
          <Default>i</Default>
          <ID>i</ID>
        </Literal>
      </Declarations>
      <Code Language="CSharp"><![CDATA[foreach (var $i$ in $items$) yield return $i$$end$;]]></Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

ฉันไม่เห็นอะไรผิดปกติกับฟังก์ชั่นของคุณฉันจะบอกว่ามันกำลังทำสิ่งที่คุณต้องการ

คิดว่าผลตอบแทนเป็นองค์ประกอบในการแจงนับครั้งสุดท้ายในแต่ละครั้งที่มีการเรียกดังนั้นเมื่อคุณมีมันในวง foreach เช่นนั้นทุกครั้งที่มีการเรียกมันก็จะส่งกลับ 1 องค์ประกอบ คุณสามารถใส่คำสั่งแบบมีเงื่อนไขลงใน foreach เพื่อกรอง resultset ได้ (เพียงโดยไม่ยอมให้เกณฑ์การยกเว้นของคุณ)

หากคุณเพิ่มอัตราผลตอบแทนที่ตามมาในภายหลังวิธีการนั้นจะเพิ่ม 1 องค์ประกอบไปยังการแจงนับทำให้เป็นไปได้ที่จะทำสิ่งต่าง ๆ เช่น ...

public IEnumerable<string> ConcatLists(params IEnumerable<string>[] lists)
{
  foreach (IEnumerable<string> list in lists)
  {
    foreach (string s in list)
    {
      yield return s;
    }
  }
}

ฉันประหลาดใจที่ไม่มีใครคิดที่จะแนะนำวิธีการต่อเติมอย่างง่าย ๆIEnumerable<IEnumerable<T>>เพื่อทำให้โค้ดนี้ยังคงทำงานตามปกติ ฉันเป็นแฟนตัวยงของการดำเนินการรอการตัดบัญชีด้วยเหตุผลหลายประการหนึ่งในนั้นคือรอยความทรงจำมีขนาดเล็กแม้สำหรับการนับจำนวนมหาศาล

public static class EnumearbleExtensions
{
    public static IEnumerable<T> UnWrap<T>(this IEnumerable<IEnumerable<T>> list)
    {
        foreach(var innerList in list)
        {
            foreach(T item in innerList)
            {
                yield return item;
            }
        }
    }
}

และคุณสามารถใช้มันในกรณีของคุณเช่นนี้

private static IEnumerable<ErrorInfo> GetErrors(Card card)
{
    return DoGetErrors(card).UnWrap();
}

private static IEnumerable<IEnumerable<ErrorInfo>> DoGetErrors(Card card)
{
    yield return GetMoreErrors(card);

    // further yield returns for more validation errors
}

ในทำนองเดียวกันคุณสามารถทำได้ด้วยฟังก์ชั่นเสื้อคลุมรอบDoGetErrorsและเพียงแค่ย้ายUnWrapไปที่เว็บไซต์

ใช่มันเป็นไปได้ที่จะกลับข้อผิดพลาดทั้งหมดในครั้งเดียว เพียงแค่ส่งกลับหรือList<T>ReadOnlyCollection<T>

โดยการส่งคืนIEnumerable<T>คุณกำลังส่งคืนลำดับของบางสิ่ง บนพื้นผิวที่อาจดูเหมือนจะเหมือนกับการคืนคอลเลกชัน แต่มีความแตกต่างจำนวนมากคุณควรจำไว้

คอลเลกชัน

• ผู้เรียกสามารถมั่นใจได้ว่าทั้งคอลเลกชันและรายการทั้งหมดจะมีอยู่เมื่อมีการส่งคืนคอลเลกชัน หากต้องสร้างคอลเลกชันต่อการโทรการส่งคืนคอลเลกชันเป็นความคิดที่ไม่ดีจริงๆ
• คอลเลกชันส่วนใหญ่สามารถแก้ไขได้เมื่อส่งคืน
• คอลเลกชันมีขนาด จำกัด

ลำดับ

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