Возвратите все перечислимые с доходностью сразу; без цикла

У меня есть следующая функция, чтобы получить ошибки проверки для карты. Мой вопрос касается работы с 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>

Я не вижу ничего плохого в вашей функции, я бы сказал, что она делает то, что вы хотите.

Думайте о Yield как о возврате элемента в окончательном перечислении каждый раз, когда он вызывается, поэтому, когда вы используете его в цикле foreach, как этот, каждый раз, когда он вызывается, он возвращает 1 элемент. У вас есть возможность поместить условные выражения в ваш foreach для фильтрации набора результатов. (просто не поддаваясь критериям исключения)

Если вы добавите последующие выходы позже в методе, он будет продолжать добавлять 1 элемент в перечисление, что позволяет делать такие вещи, как ...

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

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