Chaîner ensemble des opérateurs de requête standard (C#) (LINQ to XML)

Les opérateurs de requête standard peuvent être chaînés ensemble. Par exemple, vous pouvez interjecter l’opérateur Enumerable.Where (appelé par la clause where), et il fonctionne de manière différée ; autrement dit, aucun résultat intermédiaire n’est matérialisé par celui-ci.

Exemple : Interjecter une clause where

Dans cet exemple, la méthode Where est appelée avant ConvertCollectionToUpperCase. La méthode Where opère presque exactement de la même façon que les méthodes différées utilisées dans les exemples précédents de ce didacticiel, ConvertCollectionToUpperCase et AppendString.

Dans ce cas, la méthode Where répète à travers sa collection source, détermine que le premier élément ne passe pas le prédicat, puis obtient l’élément suivant, qui passe. Elle génère ensuite le deuxième élément.

Toutefois, l’idée de base est la même : les collections intermédiaires ne sont pas matérialisées, sauf si elles doivent l’être.

Lorsque des expressions de requête sont utilisées, elles sont converties en appels aux opérateurs de requête standard, et les mêmes principes s’appliquent.

Tous les exemples de cette section qui interrogent des documents Office Open XML utilisent le même principe. L’exécution différée et l’évaluation différée sont quelques concepts fondamentaux que vous devez comprendre pour utiliser efficacement LINQ et LINQ to XML.

public static class LocalExtensions
{
    public static IEnumerable<string>
      ConvertCollectionToUpperCase(this IEnumerable<string> source)
    {
        foreach (string str in source)
        {
            Console.WriteLine("ToUpper: source >{0}<", str);
            yield return str.ToUpper();
        }
    }

    public static IEnumerable<string>
      AppendString(this IEnumerable<string> source, string stringToAppend)
    {
        foreach (string str in source)
        {
            Console.WriteLine("AppendString: source >{0}<", str);
            yield return str + stringToAppend;
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        string[] stringArray = { "abc", "def", "ghi" };

        IEnumerable<string> q1 =
            from s in stringArray.ConvertCollectionToUpperCase()
            where s.CompareTo("D") >= 0
            select s;

        IEnumerable<string> q2 =
            from s in q1.AppendString("!!!")
            select s;

        foreach (string str in q2)
        {
            Console.WriteLine("Main: str >{0}<", str);
            Console.WriteLine();
        }
    }
}

Cet exemple produit la sortie suivante :

ToUpper: source >abc<
ToUpper: source >def<
AppendString: source >DEF<
Main: str >DEF!!!<

ToUpper: source >ghi<
AppendString: source >GHI<
Main: str >GHI!!!<

Il s’agit du dernier article du Tutoriel : Chaînage de requêtes ensemble (C#).