Повернути всі перелічні дані з віддачею одразу; не перебираючи наскрізь

У мене є така функція, щоб отримати помилки перевірки для картки. Моє запитання стосується роботи з 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()перш ніж він навіть запитає про наступні помилки.

Зазвичай це не важливо, але варто зрозуміти, що буде, коли.

Ви можете налаштувати всі такі джерела помилок (назви методів, запозичені у відповіді Джона Скіта).

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 елемент. У вас є можливість помістити умовні висловлювання в передбачення, щоб фільтрувати набір результатів. (просто не поступаючись вашим критеріям виключення)

Якщо ви додасте наступні уроки пізніше в методі, він буде продовжувати додавати 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>не робить).
• Послідовність може бути нескінченною і, таким чином, залишити її абоненту, щоб вирішити, скільки елементів потрібно повернути.