Retorne todos os enumeráveis ​​com retorno de rendimento de uma só vez; sem percorrer

Eu tenho a seguinte função para obter erros de validação para um cartão. Minha pergunta diz respeito a lidar com GetErrors. Ambos os métodos têm o mesmo tipo de retorno 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
}

É possível retornar todos os erros GetMoreErrorssem precisar enumerá-los?

Pensar nisso provavelmente é uma pergunta estúpida, mas quero ter certeza de que não estou errado.

Definitivamente, não é uma pergunta estúpida, e é algo que o F # suporta yield!para uma coleção inteira versus yieldum único item. (Isso pode ser muito útil em termos de recursão da cauda ...)

Infelizmente, não há suporte para C #.

No entanto, se você tiver vários métodos, cada um retornando um IEnumerable<ErrorInfo>, poderá usar Enumerable.Concatpara tornar seu código mais simples:

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

Porém, existe uma diferença muito importante entre as duas implementações: esta chamará todos os métodos imediatamente , mesmo que use apenas os iteradores retornados um de cada vez. Seu código existente aguardará até que ele repita tudo GetMoreErrors()antes de perguntar sobre os próximos erros.

Geralmente isso não é importante, mas vale a pena entender o que acontecerá quando.

Você pode configurar todas as fontes de erro como esta (nomes de métodos emprestados da resposta de 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();
}

Você pode iterar sobre eles ao mesmo tempo.

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

Como alternativa, você pode achatar as fontes de erro com SelectMany.

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

A execução dos métodos GetErrorSourcestambém será atrasada.

Eu vim com um yield_trecho rápido :

Aqui está o XML do trecho:

<?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>

Não vejo nada de errado com sua função, eu diria que está fazendo o que você deseja.

Pense no Yield como retornando um elemento na Enumeração final toda vez que for chamado, portanto, quando você o tiver no loop foreach assim, toda vez que for chamado, ele retornará 1 elemento. Você tem a capacidade de colocar instruções condicionais em seu foreach para filtrar o conjunto de resultados. (simplesmente não cumprindo seus critérios de exclusão)

Se você adicionar rendimentos subsequentes posteriormente no método, ele continuará adicionando 1 elemento à enumeração, possibilitando fazer coisas como ...

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

Estou surpreso que ninguém tenha pensado em recomendar um método simples de extensão IEnumerable<IEnumerable<T>>para fazer esse código manter sua execução adiada. Sou fã de execução adiada por muitas razões, uma delas é que a pegada de memória é pequena, mesmo para enumeráveis ​​enormes.

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

E você pode usá-lo no seu caso como este

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
}

Da mesma forma, você pode acabar com a função de invólucro DoGetErrorse simplesmente mudar UnWrappara o local da chamada.

Sim, é possível retornar todos os erros de uma só vez. Basta retornar um List<T>ou ReadOnlyCollection<T>.

Ao retornar um, IEnumerable<T>você está retornando uma sequência de algo. Na superfície, isso pode parecer idêntico ao retorno da coleção, mas há várias diferenças, você deve ter em mente.

Colecções

• O chamador pode ter certeza de que a coleção e todos os itens existirão quando a coleção for retornada. Se a coleção precisar ser criada por chamada, retornar uma coleção é uma péssima idéia.
• A maioria das coleções pode ser modificada quando retornada.
• A coleção é de tamanho finito.

Sequências

• Pode ser enumerado - e isso é tudo o que podemos dizer com certeza.
• Uma sequência retornada em si não pode ser modificada.
• Cada elemento pode ser criado como parte da execução da sequência (ou seja, o retorno IEnumerable<T>permite uma avaliação lenta, o retorno List<T>não).
• Uma sequência pode ser infinita e, assim, deixar para o chamador decidir quantos elementos devem ser retornados.