Retourner tous les énumérables avec yield return en une seule fois ; sans passer par la boucle.

Question

J'ai la fonction suivante pour obtenir les erreurs de validation pour une carte. Ma question porte sur le traitement de la méthode GetErrors. Les deux méthodes ont le même type de retour 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
}

Est-il possible de renvoyer toutes les erreurs dans GetMoreErrors sans avoir à les énumérer ?

Answer 1

Ce n'est absolument pas une question stupide, et c'est quelque chose que F# prend en charge grâce à la fonction yield! pour une collection complète vs yield pour un seul élément. (Cela peut être très utile en termes de récursion de queue...)

Malheureusement, il n'est pas supporté en C#.

Toutefois, si vous avez plusieurs méthodes qui renvoient chacune un fichier IEnumerable<ErrorInfo> vous pouvez utiliser Enumerable.Concat pour rendre votre code plus simple :

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

Il y a cependant une différence très importante entre les deux implémentations : celle-ci appelle toutes les méthodes immédiatement même si elle n'utilise les itérateurs retournés qu'un par un. Votre code existant attendra jusqu'à ce qu'il ait parcouru en boucle tout ce qui se trouve dans le fichier GetMoreErrors() avant même qu'il ne soit demande sur les prochaines erreurs.

En général, ce n'est pas important, mais il est bon de comprendre ce qui va se passer quand.

Answer 2

Vous pourriez configurer toutes les sources d'erreur comme ceci (noms de méthodes empruntés à la réponse 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();
}

Vous pouvez alors itérer sur eux en même temps.

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

Vous pouvez également aplatir les sources d'erreur avec SelectMany .

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

L'exécution des méthodes dans GetErrorSources sera également retardé.

Answer 3

Je ne vois rien de mal dans votre fonction, je dirais qu'elle fait ce que vous voulez.

Considérez que le rendement renvoie un élément de l'énumération finale chaque fois qu'il est invoqué. Ainsi, lorsque vous l'avez dans la boucle foreach, chaque fois qu'il est invoqué, il renvoie un élément. Vous avez la possibilité d'insérer des instructions conditionnelles dans votre foreach pour filtrer le jeu de résultats. (simplement en ne retournant pas vos critères d'exclusion)

Si vous ajoutez des rendements ultérieurs plus tard dans la méthode, celle-ci continuera à ajouter 1 élément à l'énumération, ce qui permet de faire des choses comme...

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

Answer 4

Oui, il est possible de renvoyer toutes les erreurs en même temps. Il suffit de renvoyer une List<T> o ReadOnlyCollection<T> .

En renvoyant un IEnumerable<T> vous retournez une séquence de quelque chose. À première vue, cela peut sembler identique au renvoi de la collection, mais il y a un certain nombre de différences que vous devez garder à l'esprit.

Collections

• L'appelant peut être sûr que la collection et tous les éléments existeront lorsque la collection sera retournée. Si la collection doit être créée à chaque appel, retourner une collection est une très mauvaise idée.
• La plupart des collections peuvent être modifiées au retour.
• La collection est de taille finie.

Séquences

• On peut les énumérer - et c'est à peu près tout ce que nous pouvons dire avec certitude.
• Une séquence retournée ne peut pas être modifiée.
• Chaque élément peut être créé dans le cadre de l'exécution de la séquence (c'est-à-dire en retournant les données de la séquence). IEnumerable<T> permet une évaluation paresseuse, en retournant List<T> ne le fait pas).
• Une séquence peut être infinie et donc laisser à l'appelant le soin de décider du nombre d'éléments à renvoyer.

Answer 5

El yield est spécifiquement conçu pour renvoyer un élément d'une liste d'éléments. IEnumerable à chaque fois que vous appelez la méthode.

Si vous souhaitez obtenir toute la collection en une seule fois, vous pouvez simplement modifier le type de retour de la méthode et return l'ensemble de la collection directement.

Quelque chose comme ceci (en supposant que GetMoreErrors() renvoie un List<> ) :

private static List<ErrorInfo> GetErrors(Card card)
{
    return GetMoreErrors(card);
}

Yield est juste un moyen pratique pour qu'une méthode s'occupe de l'itération à votre place... une pièce récupérée à chaque fois que vous appelez GetErrors() . Si vous retournez la collection entière, vous finirez probablement par itérer à travers la collection d'erreurs de toute façon, donc c'est juste une question de savoir où vous voulez voir l'icône de l'erreur. foreach() code.