LINQ Advanced

🎯 LINQ Advanced: The Master Chef’s Kitchen

Imagine you’re a master chef in a huge restaurant kitchen. You have TONS of ingredients (data), and LINQ Advanced is your set of super-powered kitchen tools that help you organize, combine, and transform everything perfectly!

🔀 OrderBy Operations: Sorting Your Ingredients

The Story: Picture your kitchen shelves as a messy pile of vegetables. OrderBy is like having a magic wand that instantly arranges everything in perfect order!

Basic Sorting (OrderBy & OrderByDescending)

Think of it like lining up your spices from A to Z, or Z to A.

var fruits = new[] {
  "Banana", "Apple", "Cherry"
};

// A to Z (ascending)
var sorted = fruits
  .OrderBy(f => f);
// Result: Apple, Banana, Cherry

// Z to A (descending)
var reversed = fruits
  .OrderByDescending(f => f);
// Result: Cherry, Banana, Apple

Multi-Level Sorting (ThenBy)

What if two fruits have the same name? Sort by name first, then by size!

var items = new[] {
  new { Name = "Apple", Size = 3 },
  new { Name = "Apple", Size = 1 },
  new { Name = "Banana", Size = 2 }
};

var sorted = items
  .OrderBy(x => x.Name)
  .ThenBy(x => x.Size);
// Apples together, smaller first!

🧙‍♂️ Magic Tip: Use ThenByDescending to reverse the second sort!

📦 GroupBy Operations: Sorting Into Boxes

The Story: Imagine you have a basket of mixed candies. GroupBy is like having magical boxes that automatically catch all candies of the same color!

var candies = new[] {
  new { Color = "Red", Name = "Cherry" },
  new { Color = "Red", Name = "Strawberry" },
  new { Color = "Yellow", Name = "Lemon" }
};

var grouped = candies
  .GroupBy(c => c.Color);

// Now you have:
// Box "Red": Cherry, Strawberry
// Box "Yellow": Lemon

Counting Inside Groups

How many candies in each box?

foreach (var group in grouped) {
  Console.WriteLine(
    quot;{group.Key}: {group.Count()} candies"
  );
}
// Red: 2 candies
// Yellow: 1 candies

graph TD
    A["🍬 All Candies"] --> B["GroupBy Color"]
    B --> C["📦 Red Box"]
    B --> D["📦 Yellow Box"]
    C --> E["Cherry, Strawberry"]
    D --> F["Lemon"]

🤝 Joins: Connecting Puzzle Pieces

The Story: You have two puzzle sets - one with pictures of animals, one with their names. Join is the magic that matches each picture to its correct name!

Inner Join (Only Matches)

Only pieces that fit together appear in the result.

var animals = new[] {
  new { Id = 1, Name = "Cat" },
  new { Id = 2, Name = "Dog" }
};

var sounds = new[] {
  new { AnimalId = 1, Sound = "Meow" },
  new { AnimalId = 2, Sound = "Woof" }
};

var joined = animals.Join(
  sounds,              // second collection
  a => a.Id,           // key from animals
  s => s.AnimalId,     // key from sounds
  (a, s) => new {      // result
    a.Name, s.Sound
  }
);
// Result: Cat-Meow, Dog-Woof

Group Join (All From Left + Matches)

Keep ALL animals, even if they don’t have sounds!

var result = animals.GroupJoin(
  sounds,
  a => a.Id,
  s => s.AnimalId,
  (animal, matchingSounds) => new {
    animal.Name,
    Sounds = matchingSounds
  }
);

graph TD
    A["🐱 Animals"] --> C["🔗 JOIN"]
    B["🔊 Sounds"] --> C
    C --> D["Cat + Meow"]
    C --> E["Dog + Woof"]

🧮 Aggregation: Crunching Numbers

The Story: You have a piggy bank full of coins. Aggregation operations are like magical calculators that instantly tell you totals, averages, and more!

The Big Five Aggregators

var scores = new[] { 85, 92, 78, 95, 88 };

// Total of all scores
var sum = scores.Sum();        // 438

// How many scores?
var count = scores.Count();    // 5

// Average score
var avg = scores.Average();    // 87.6

// Highest score
var max = scores.Max();        // 95

// Lowest score
var min = scores.Min();        // 78

Custom Aggregation (Aggregate)

Make your own calculation! Like multiplying all numbers together:

var numbers = new[] { 2, 3, 4 };

var product = numbers.Aggregate(
  (total, next) => total * next
);
// 2 × 3 × 4 = 24

🚀 Pro Tip: Aggregate starts with the first item, then applies your function to each remaining item!

🎯 Element Operations: Finding Specific Items

The Story: You’re looking for a specific toy in your toy box. Element operations are like having X-ray vision to find exactly what you want!

Finding Elements

var toys = new[] { "Car", "Doll", "Ball" };

// First toy
var first = toys.First();      // "Car"

// Last toy
var last = toys.Last();        // "Ball"

// Find specific toy
var car = toys.First(
  t => t == "Car"
);                              // "Car"

// Safe way (won't crash)
var robot = toys.FirstOrDefault(
  t => t == "Robot"
);                              // null

⚠️ Safety First: Always use ...OrDefault() when you’re not sure the item exists!

🎭 Set Operations: Playing with Collections

The Story: You and your friend both have sticker collections. Set operations help you figure out which stickers you share, which are unique, and how to combine them!

The Set Family

var myStickers = new[] {
  "Star", "Moon", "Sun"
};
var friendStickers = new[] {
  "Moon", "Cloud", "Sun"
};

// What do we BOTH have?
var both = myStickers
  .Intersect(friendStickers);
// Moon, Sun

// What's DIFFERENT between us?
var onlyMine = myStickers
  .Except(friendStickers);
// Star

// ALL stickers combined (no duplicates)
var all = myStickers
  .Union(friendStickers);
// Star, Moon, Sun, Cloud

// Remove MY duplicates
var unique = new[] { "A", "A", "B" }
  .Distinct();
// A, B

graph TD
    A["My Stickers 🌟🌙☀️"] --> E["Set Operations"]
    B["Friend Stickers 🌙☁️☀️"] --> E
    E --> F["Intersect: 🌙☀️"]
    E --> G["Except: 🌟"]
    E --> H["Union: 🌟🌙☀️☁️"]

🔄 Conversion Methods: Shape-Shifting Data

The Story: You have clay (data) and you need to mold it into different shapes - lists, arrays, dictionaries! Conversion methods are your magical molds!

Converting Collections

var query = numbers.Where(n => n > 5);

// To Array (fixed size)
int[] arr = query.ToArray();

// To List (can add/remove)
List<int> list = query.ToList();

// To Dictionary (key-value pairs)
var fruits = new[] {
  new { Id = 1, Name = "Apple" },
  new { Id = 2, Name = "Banana" }
};

var dict = fruits.ToDictionary(
  f => f.Id,    // key
  f => f.Name   // value
);
// {1: "Apple", 2: "Banana"}

Other Conversions

// ToHashSet - unique items, super fast lookup
HashSet<int> set = numbers.ToHashSet();

// ToLookup - like Dictionary but with GROUPS
var lookup = fruits.ToLookup(f => f.Id);

// AsEnumerable - for query composition
var asEnum = fruits.AsEnumerable();

// Cast - convert all items to specific type
var objects = new object[] { 1, 2, 3 };
var ints = objects.Cast<int>();

// OfType - only items of specific type
var mixed = new object[] { 1, "hi", 2 };
var onlyInts = mixed.OfType<int>();
// 1, 2

🎓 Putting It All Together

Here’s a real-world example using EVERYTHING:

var students = new[] {
  new { Name = "Ana", Grade = "A", Score = 95 },
  new { Name = "Bob", Grade = "B", Score = 85 },
  new { Name = "Cat", Grade = "A", Score = 92 },
  new { Name = "Dan", Grade = "B", Score = 88 }
};

var report = students
  .GroupBy(s => s.Grade)       // Group by grade
  .Select(g => new {
    Grade = g.Key,
    Average = g.Average(s => s.Score),
    TopStudent = g
      .OrderByDescending(s => s.Score)
      .First().Name
  })
  .OrderBy(r => r.Grade)       // Sort A, B, C...
  .ToList();                   // Convert to List

// Grade A: Avg 93.5, Top: Ana
// Grade B: Avg 86.5, Top: Dan

🌟 Summary

🎉 You did it! You now have all the advanced LINQ superpowers. Go forth and transform data like a pro!