LINQ ב-C#: Where, Select, OrderBy, GroupBy ועוד

LINQ (Language Integrated Query) היא ספרייה של מתודות לסינון, שינוי, מיון, קיבוץ וסיכום של רצפים. הוסיפו using System.Linq; וכל מערך, List<T>, Dictionary וכל IEnumerable<T> אחר מקבלים מתודות כמו Where, Select ו-OrderBy, שכל אחת מהן מקבלת lambda שאומרת מה לעשות עם איבר אחד.

שאילתה ראשונה: תחביר מתודות ותחביר שאילתות

ל-LINQ יש שני סימונים. תחביר המתודות משרשר קריאות; תחביר השאילתות נקרא כמו SQL. הקומפיילר הופך את תחביר השאילתות לאותן קריאות למתודות, ולכן הם מפיקים תוצאות זהות.

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] scores = { 72, 95, 60, 88, 79, 91 };

        // Method syntax
        IEnumerable<int> high = scores
            .Where(s => s >= 80)
            .OrderByDescending(s => s);

        // Query syntax: the same query
        IEnumerable<int> high2 =
            from s in scores
            where s >= 80
            orderby s descending
            select s;

        Console.WriteLine(string.Join(", ", high));
        Console.WriteLine(string.Join(", ", high2));
    }
}

פלט:

95, 91, 88
95, 91, 88

תחביר המתודות נפוץ יותר בקוד מודרני, וחלק מהאופרטורים (Take, Distinct, Count, First, ToList) קיימים רק כמתודות. תחביר השאילתות בולט ב-joins ובשאילתות שמכניסות משתני ביניים עם let. שאר העמוד משתמש בתחביר המתודות ומראה את תחביר השאילתות כשהוא מוסיף משהו.

Where ו-Select: סינון והטלה

Where שומר את האיברים שמתאימים לתנאי. Select הופך כל איבר למשהו אחר. יחד הם מכסים את רוב השאילתות היומיומיות.

using System;
using System.Collections.Generic;
using System.Linq;

class Product
{
    public string Name;
    public string Category;
    public decimal Price;
    public Product(string n, string c, decimal p) { Name = n; Category = c; Price = p; }
}

class Program
{
    static void Main()
    {
        var products = new List<Product>
        {
            new Product("Mug", "Kitchen", 8.50m),
            new Product("Lamp", "Home", 32.00m),
            new Product("Kettle", "Kitchen", 27.00m),
            new Product("Rug", "Home", 120.00m),
        };

        IEnumerable<string> cheapNames = products
            .Where(p => p.Price < 30m)
            .Select(p => p.Name);
        Console.WriteLine(string.Join(", ", cheapNames));

        var labels = products.Select(p => p.Name.ToUpper() + " $" + p.Price);
        Console.WriteLine(string.Join(" | ", labels));

        // An anonymous type holds a few properties without declaring a class.
        var summary = products
            .Where(p => p.Category == "Home")
            .Select(p => new { p.Name, WithTax = Math.Round(p.Price * 1.2m, 2) });
        foreach (var item in summary)
        {
            Console.WriteLine(item.Name + ": " + item.WithTax);
        }

        // Select also has an overload with the index.
        var numbered = products.Select((p, i) => (i + 1) + ". " + p.Name);
        Console.WriteLine(string.Join(" ", numbered));
    }
}

פלט:

Mug, Kettle
MUG $8.50 | LAMP $32.00 | KETTLE $27.00 | RUG $120.00
Lamp: 38.40
Rug: 144.00
1. Mug 2. Lamp 3. Kettle 4. Rug

Where אף פעם לא משנה איברים, ו-Select אף פעם לא משנה את הכמות שלהם. new { p.Name, WithTax = ... } יוצר טיפוס אנונימי, מחלקה שהקומפיילר כותב בשבילכם, שאת המאפיינים שלה קוראים בתחביר נקודה רגיל. אין לו שם שאפשר לכתוב, ולכן משתנה שמחזיק אחד כזה חייב להיות מוצהר עם var, והוא מתאים לתוצאות שנשארות בתוך מתודה אחת.

OrderBy, ThenBy ומיון לפי כמה מפתחות

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var orders = new List<(string Customer, decimal Total)>
        {
            ("Ben", 40m), ("Ana", 15m), ("Ben", 90m), ("Ana", 60m), ("Chloe", 25m),
        };

        var sorted = orders
            .OrderBy(o => o.Customer)            // first key
            .ThenByDescending(o => o.Total);     // tie breaker
        foreach (var o in sorted)
        {
            Console.WriteLine(o.Customer + " " + o.Total);
        }

        var query =
            from o in orders
            orderby o.Total descending
            select o.Customer;
        Console.WriteLine(string.Join(", ", query));
    }
}

פלט:

Ana 60
Ana 15
Ben 90
Ben 40
Chloe 25
Ben, Ana, Ben, Chloe, Ana

OrderBy יציב: איברים עם מפתחות שווים נשארים בסדר המקורי שלהם. השתמשו ב-ThenBy או ב-ThenByDescending למפתח שני. OrderBy שני היה ממיין מחדש הכול לפי המפתח שלו, ומשאיר את המפתח הראשון רק כמכריע בשוויון: עדיפות הפוכה. בתחביר השאילתות, המפתחות מופרדים בפסיקים: orderby o.Customer, o.Total descending.

בניגוד ל-List<T>.Sort, OrderBy לא נוגע במקור ומחזיר רצף חדש.

First, Single, Last והגרסאות שלהם עם OrDefault

אלה מחזירים איבר אחד במקום רצף. הגרסאות הרגילות זורקות חריגה כשאין מה להחזיר; גרסאות ה-OrDefault מחזירות את ערך ברירת המחדל של הטיפוס.

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var names = new List<string> { "Ana", "Ben", "Bea", "Chloe" };

        Console.WriteLine(names.First());
        Console.WriteLine(names.First(n => n.StartsWith("B")));
        Console.WriteLine(names.Last(n => n.StartsWith("B")));
        Console.WriteLine(names.FirstOrDefault(n => n.StartsWith("Z")) == null);

        try
        {
            names.First(n => n.StartsWith("Z"));
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine("First: " + e.GetType().Name);
        }

        try
        {
            names.Single(n => n.StartsWith("B")); // two matches
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine("Single: " + e.GetType().Name);
        }

        int[] scores = { 72, 95 };
        Console.WriteLine(scores.FirstOrDefault(s => s > 100)); // 0, not "missing"
    }
}

פלט:

Ana
Ben
Bea
True
First: InvalidOperationException
Single: InvalidOperationException
0

החריגה מ-First על רצף ריק היא InvalidOperationException עם ההודעה "Sequence contains no elements" (או "Sequence contains no matching element" כשפרדיקט לא התאים לכלום), אחת השגיאות הכי מחופשות ב-C#. השתמשו ב-FirstOrDefault כש"אין כלום" היא תוצאה רגילה, ובדקו אם התקבל null.

השורה האחרונה מראה את המלכודת של טיפוסי ערך: ברצף של int, FirstOrDefault מחזיר 0 כששום דבר לא מתאים, ואי אפשר להבחין בינו לבין 0 אמיתי. סננו עם Where ובדקו קודם Any(), או ב-.NET 6 ואילך העבירו ברירת מחדל משלכם: scores.FirstOrDefault(s => s > 100, -1).

Single מיועד ל"בדיוק אחד": הוא זורק חריגה אם אין אף אחד או שיש יותר מאחד, מה שהופך אותו לטענה (assertion) לא פחות משאילתה.

Any, All, Count ו-Contains

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] ages = { 17, 22, 35, 41, 16 };

        Console.WriteLine(ages.Any());                 // is it non-empty?
        Console.WriteLine(ages.Any(a => a < 18));      // at least one minor?
        Console.WriteLine(ages.All(a => a >= 16));     // everyone 16 or older?
        Console.WriteLine(ages.Count(a => a >= 18));   // how many adults?
        Console.WriteLine(ages.Contains(35));

        int[] none = { };
        Console.WriteLine(none.All(a => a > 100));      // true for an empty sequence
    }
}

פלט:

True
True
True
3
True
True

Any() עוצר בהתאמה הראשונה, ולכן items.Any() היא הדרך הנכונה לשאול "יש משהו?". items.Count() > 0 קורא את המאפיין Count כשהמקור הוא אוסף כמו רשימה או מערך, אבל על שאילתה או רצף עצל אחר הוא עובר קודם על כל האיברים. All על רצף ריק מחזיר true, כי אין אף איבר שנכשל בתנאי.

Sum, Average, Min ו-Max

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var cart = new List<(string Item, decimal Price, int Qty)>
        {
            ("Tea", 4.50m, 2), ("Honey", 7.25m, 1), ("Cups", 3.00m, 4),
        };

        Console.WriteLine("Total: " + cart.Sum(c => c.Price * c.Qty));
        Console.WriteLine("Items: " + cart.Sum(c => c.Qty));
        Console.WriteLine("Priciest: " + cart.Max(c => c.Price));
        Console.WriteLine("Average price: " + cart.Average(c => c.Price).ToString("F2"));

        var empty = new List<int>();
        Console.WriteLine(empty.Sum());
        try
        {
            empty.Average();
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine("Average: " + e.GetType().Name);
        }
    }
}

פלט:

Total: 28.25
Items: 7
Priciest: 7.25
Average price: 4.92
0
Average: InvalidOperationException

Sum של רצף ריק הוא 0, אבל Average, Min ו-Max של רצף ריק של מספרים זורקים InvalidOperationException: אין תשובה הגיונית. הגנו עם Any(), או השתמשו קודם ב-DefaultIfEmpty(): empty.DefaultIfEmpty(0).Average().

Distinct, Take ו-Skip

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        string[] visits = { "home", "shop", "home", "cart", "shop", "home" };
        Console.WriteLine(string.Join(", ", visits.Distinct()));

        int[] ids = Enumerable.Range(1, 23).ToArray(); // 1..23
        int pageSize = 10;
        for (int page = 0; page * pageSize < ids.Length; page++)
        {
            var items = ids.Skip(page * pageSize).Take(pageSize);
            Console.WriteLine("Page " + (page + 1) + ": " + string.Join(" ", items));
        }

        int[] temps = { 12, 15, 21, 24, 19, 11 };
        Console.WriteLine(string.Join(", ", temps.TakeWhile(t => t < 20)));
    }
}

פלט:

home, shop, cart
Page 1: 1 2 3 4 5 6 7 8 9 10
Page 2: 11 12 13 14 15 16 17 18 19 20
Page 3: 21 22 23
12, 15

Distinct שומר את המופע הראשון של כל ערך לפי הסדר. Skip(n).Take(m) היא התבנית הסטנדרטית לחלוקה לעמודים, ו-TakeWhile/SkipWhile עוצרים או מתחילים באיבר הראשון שנכשל בתנאי. Enumerable.Range(start, count) מייצר רצף של מספרים שלמים בלי מערך.

GroupBy

GroupBy ממיין איברים לדליים לפי מפתח. לכל קבוצה יש Key והיא עצמה רצף, ולכן אפשר לבצע עליה צבירה.

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var sales = new List<(string Region, string Rep, int Amount)>
        {
            ("North", "Ana", 300), ("South", "Ben", 150), ("North", "Chloe", 200),
            ("East", "Dev", 350), ("South", "Eli", 250), ("North", "Ana", 100),
        };

        foreach (var g in sales.GroupBy(s => s.Region))
        {
            Console.WriteLine(g.Key + ": " + g.Count() + " sales, total " + g.Sum(s => s.Amount));
        }

        var top = sales
            .GroupBy(s => s.Rep)
            .Select(g => new { Rep = g.Key, Total = g.Sum(s => s.Amount) })
            .OrderByDescending(x => x.Total)
            .First();
        Console.WriteLine("Top rep: " + top.Rep + " " + top.Total);

        var byRegion =
            from s in sales
            group s.Rep by s.Region into g
            select g.Key + " -> " + string.Join("/", g);
        Console.WriteLine(string.Join("; ", byRegion));
    }
}

פלט:

North: 3 sales, total 600
South: 2 sales, total 400
East: 1 sales, total 350
Top rep: Ana 400
North -> Ana/Chloe/Ana; South -> Ben/Eli; East -> Dev

הקבוצות יוצאות בסדר שבו המפתחות שלהן מופיעים לראשונה במקור (North, South, East), לא ממוינות; הוסיפו OrderBy(g => g.Key) אם צריך מיון. בתחביר השאילתות, group X by K בוחר מה נכנס לכל קבוצה (כאן רק השם של הנציג) ו-into g נותן שם לקבוצה כדי שהשאילתה תוכל להמשיך.

ToList, ToArray ו-ToDictionary

המתודות To... מריצות את השאילתה ושומרות את התוצאות.

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var users = new List<(int Id, string Email)>
        {
            (1, "ana@x.com"), (2, "ben@x.com"), (3, "cy@x.com"),
        };

        Dictionary<int, string> byId = users.ToDictionary(u => u.Id, u => u.Email);
        Console.WriteLine(byId[2]);

        var wordCounts = "to be or not to be".Split(' ')
            .GroupBy(w => w)
            .ToDictionary(g => g.Key, g => g.Count());
        Console.WriteLine(wordCounts["be"]);

        try
        {
            users.ToDictionary(u => u.Email.Length); // two emails of length 9
        }
        catch (ArgumentException e)
        {
            Console.WriteLine("ToDictionary: " + e.GetType().Name);
        }
    }
}

פלט:

ben@x.com
2
ToDictionary: ArgumentException

ToDictionary זורק ArgumentException כששני איברים מפיקים את אותו מפתח, בדיוק כמו Dictionary.Add. אם צפויות כפילויות, קבצו קודם (כמו ש-wordCounts עושה) או השתמשו ב-ToLookup, שממפה כל מפתח לרצף של ערכים.

ביצוע נדחה

Where, Select, OrderBy, GroupBy ורוב האופרטורים האחרים מחזירים אובייקט שאילתה ולא עושים שום עבודה עד שמשהו עובר עליו. יש לזה שתי השלכות ששווה לראות:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var prices = new List<int> { 10, 25, 40 };

        IEnumerable<int> expensive = prices.Where(p => p > 20); // nothing runs yet
        prices.Add(99);                                        // added after the query
        Console.WriteLine(string.Join(", ", expensive));        // runs now, sees 99

        IEnumerable<int> logged = prices.Select(p =>
        {
            Console.WriteLine("  converting " + p);
            return p * 100;
        });

        Console.WriteLine("Count: " + logged.Count());          // runs the query once
        Console.WriteLine("Max: " + logged.Max());              // and again

        List<int> cached = logged.ToList();                     // run once, keep results
        Console.WriteLine("Cached: " + cached.Count + ", " + cached.Max());
    }
}

פלט:

25, 40, 99
  converting 10
  converting 25
  converting 40
  converting 99
Count: 4
  converting 10
  converting 25
  converting 40
  converting 99
Max: 9900
  converting 10
  converting 25
  converting 40
  converting 99
Cached: 4, 9900

השאילתה הראשונה ראתה את 99 למרות שהוא נוסף אחרי שהשאילתה נכתבה: הסינון רץ כש-string.Join עבר עליה. השאילתה השנייה הדפיסה את ההמרות שלה פעמיים כי Count() ו-Max() עברו עליה כל אחד מההתחלה. עם lambda זולה זו רק עבודה מבוזבזת; עם שאילתה למסד נתונים, קריאה מקובץ או מספר אקראי בתוך ה-lambda, שני המעברים יכולים להחזיר נתונים שונים. כשתשתמשו בתוצאה יותר מפעם אחת, ממשו אותה עם ToList() או ToArray().

אופרטורים שמחזירים ערך יחיד (Count, Sum, First, Any, Max) והמתודות To... רצים מיד. ראו IEnumerable ו-yield כדי להבין איך העצלות הזו בנויה.

טבלת עזר מהירה

טעויות נפוצות

• First() על רצף שיכול להיות ריק. זורק "Sequence contains no elements"; השתמשו ב-FirstOrDefault ובדקו.
• שתי קריאות ל-OrderBy. המפתח השני הופך לראשי; השתמשו ב-ThenBy.
• מעבר על שאילתה כמה פעמים. העבודה חוזרת על עצמה; קראו ל-ToList() פעם אחת.
• ציפייה ששאילתה תשמור תמונת מצב של המקור. היא קוראת את המקור כשעוברים עליה, לא כשכותבים אותה.
• Average, Min, Max על רצף ריק. הם זורקים חריגה; הגנו עם Any() או DefaultIfEmpty.
• Count() > 0 כדי לבדוק אם יש איברים. Any() עוצר באיבר הראשון.