Łączenie standardowych operatorów zapytań (C#) (LINQ to XML)

Standardowe operatory zapytań można połączyć ze sobą. Można na przykład przeplatać Enumerable.Where operator (wywoływany przez where klauzulę) i działać w sposób leniwy, czyli nie są materializowane żadne wyniki pośrednie.

Przykład: Przecięcie klauzuli where

W tym przykładzie metoda jest wywoływana Where przed wywołaniem ConvertCollectionToUpperCasemetody . Metoda Where działa w niemal dokładnie taki sam sposób, jak metody leniwe używane w poprzednich przykładach w tym samouczku ConvertCollectionToUpperCase i AppendString.

Jedną z różnic jest to, że w tym przypadku metoda iteruje za pośrednictwem kolekcji źródłowej, określa, Where że pierwszy element nie przekazuje predykatu, a następnie pobiera następny element, który przechodzi. Następnie zwraca drugi element.

Jednak podstawowa idea jest taka sama: kolekcje pośrednie nie są zmaterializowane, chyba że muszą być.

Gdy są używane wyrażenia zapytania, są konwertowane na wywołania do standardowych operatorów zapytań, a te same zasady mają zastosowanie.

Wszystkie przykłady w tej sekcji, które wysyłają zapytania do dokumentów Office Open XML, używają tej samej zasady. Odroczone wykonywanie i leniwa ocena to niektóre z podstawowych pojęć, które należy zrozumieć, aby efektywnie używać LINQ i 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();
        }
    }
}

Ten przykład generuje następujące wyniki:

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

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

Jest to ostatni artykuł w samouczku Tutorial: Chaining Queries Together (C#) (Samouczek: łączenie zapytań w łańcuchy (C#).