C#: Understanding LINQ

// Solution 1: Basic LINQ operations with method syntax
using System;
using System.Collections.Generic;
using System.Linq;

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

// Filtering with Where
var evenNumbers = numbers.Where(n => n % 2 == 0).ToList();
var numbersGreaterThanFive = numbers.Where(n => n > 5);

// Projection with Select
var squares = numbers.Select(n => n * n);
var numberStrings = numbers.Select(n => $"Number: {n}");

// Sorting with OrderBy and OrderByDescending
var ascending = numbers.OrderBy(n => n);
var descending = numbers.OrderByDescending(n => n);

// Aggregation methods
int sum = numbers.Sum();
double average = numbers.Average();
int max = numbers.Max();
int min = numbers.Min();
int count = numbers.Count(n => n > 5);

// First, FirstOrDefault, Last, LastOrDefault
int firstEven = numbers.First(n => n % 2 == 0);  // Throws if not found
int firstEvenOrDefault = numbers.FirstOrDefault(n => n % 2 == 0);  // Returns 0 if not found
bool anyEven = numbers.Any(n => n % 2 == 0);
bool allPositive = numbers.All(n => n > 0);

Console.WriteLine($"Even numbers: {string.Join(", ", evenNumbers)}");
Console.WriteLine($"Sum: {sum}, Average: {average:F2}");

// Working with complex objects
public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
    public string Department { get; set; }
    public decimal Salary { get; set; }
}

List<Person> employees = new List<Person>
{
    new Person { FirstName = "Alice", LastName = "Johnson", Age = 30, Department = "IT", Salary = 75000 },
    new Person { FirstName = "Bob", LastName = "Smith", Age = 25, Department = "Sales", Salary = 65000 },
    new Person { FirstName = "Charlie", LastName = "Brown", Age = 35, Department = "IT", Salary = 80000 },
    new Person { FirstName = "Diana", LastName = "Wilson", Age = 28, Department = "Marketing", Salary = 60000 },
    new Person { FirstName = "Eve", LastName = "Davis", Age = 32, Department = "IT", Salary = 85000 }
};

// Complex filtering and projection
var itEmployees = employees
    .Where(e => e.Department == "IT")
    .OrderByDescending(e => e.Salary)
    .Select(e => new { e.FirstName, e.LastName, e.Salary })
    .ToList();

// Grouping
var employeesByDepartment = employees
    .GroupBy(e => e.Department)
    .Select(g => new 
    { 
        Department = g.Key, 
        Count = g.Count(), 
        AverageSalary = g.Average(e => e.Salary) 
    });

foreach (var group in employeesByDepartment)
{
    Console.WriteLine($"Department: {group.Department}, Count: {group.Count}, Avg Salary: {group.AverageSalary:C}");
}

// Solution 2: Query expression syntax
// Query syntax (SQL-like)
var queryResult = from person in employees
                  where person.Age > 30
                  orderby person.Salary descending
                  select new { person.FirstName, person.Age, person.Salary };

// Complex query with multiple operations
var complexQuery = from person in employees
                   where person.Department == "IT"
                   group person by person.Age > 30 into ageGroup
                   select new
                   {
                       IsOver30 = ageGroup.Key,
                       Count = ageGroup.Count(),
                       TotalSalary = ageGroup.Sum(p => p.Salary)
                   };

// Join operations
public class Department
{
    public string Name { get; set; }
    public string Location { get; set; }
    public string Manager { get; set; }
}

List<Department> departments = new List<Department>
{
    new Department { Name = "IT", Location = "Building A", Manager = "John Doe" },
    new Department { Name = "Sales", Location = "Building B", Manager = "Jane Smith" },
    new Department { Name = "Marketing", Location = "Building C", Manager = "Mike Johnson" }
};

// Inner join using method syntax
var employeeWithDepartmentInfo = employees.Join(
    departments,
    employee => employee.Department,
    department => department.Name,
    (employee, department) => new
    {
        employee.FirstName,
        employee.LastName,
        employee.Department,
        department.Location,
        department.Manager
    }
);

// Join using query syntax
var joinQuery = from emp in employees
                join dept in departments on emp.Department equals dept.Name
                select new
                {
                    EmployeeName = $"{emp.FirstName} {emp.LastName}",
                    emp.Department,
                    dept.Location,
                    dept.Manager
                };

// Solution 3: Advanced LINQ operations
// SelectMany for flattening collections
List<List<int>> nestedNumbers = new List<List<int>>
{
    new List<int> { 1, 2, 3 },
    new List<int> { 4, 5, 6 },
    new List<int> { 7, 8, 9 }
};

var flattenedNumbers = nestedNumbers.SelectMany(list => list);
Console.WriteLine($"Flattened: {string.Join(", ", flattenedNumbers)}");

// SelectMany with projection
var employeeSkills = employees.SelectMany(emp => 
    GetSkillsForEmployee(emp.FirstName), 
    (emp, skill) => new { Employee = emp.FirstName, Skill = skill }
);

// Distinct operations
var distinctDepartments = employees.Select(e => e.Department).Distinct();

// Set operations
List<int> list1 = new List<int> { 1, 2, 3, 4, 5 };
List<int> list2 = new List<int> { 4, 5, 6, 7, 8 };

var union = list1.Union(list2);        // { 1, 2, 3, 4, 5, 6, 7, 8 }
var intersect = list1.Intersect(list2); // { 4, 5 }
var except = list1.Except(list2);       // { 1, 2, 3 }

// Partitioning
var firstThreeEmployees = employees.Take(3);
var skipFirstTwo = employees.Skip(2);
var pagedResults = employees.Skip(2).Take(2); // Simple pagination

// TakeWhile and SkipWhile
var numbersUntilFirstEven = numbers.TakeWhile(n => n % 2 != 0);
var numbersAfterFirstEven = numbers.SkipWhile(n => n % 2 != 0);

// Custom comparers
var customSorted = employees.OrderBy(e => e.LastName, StringComparer.OrdinalIgnoreCase);

// Solution 4: LINQ with different data sources
// LINQ to XML
using System.Xml.Linq;

XDocument xmlDoc = XDocument.Parse(@"
<employees>
    <employee id='1'>
        <name>Alice Johnson</name>
        <department>IT</department>
        <salary>75000</salary>
    </employee>
    <employee id='2'>
        <name>Bob Smith</name>
        <department>Sales</department>
        <salary>65000</salary>
    </employee>
</employees>");

var xmlEmployees = from emp in xmlDoc.Descendants("employee")
                   select new
                   {
                       Id = emp.Attribute("id")?.Value,
                       Name = emp.Element("name")?.Value,
                       Department = emp.Element("department")?.Value,
                       Salary = decimal.Parse(emp.Element("salary")?.Value ?? "0")
                   };

// LINQ with dictionaries
Dictionary<string, int> scores = new Dictionary<string, int>
{
    { "Alice", 95 },
    { "Bob", 87 },
    { "Charlie", 92 },
    { "Diana", 89 }
};

var highScores = scores
    .Where(kvp => kvp.Value > 90)
    .OrderByDescending(kvp => kvp.Value)
    .ToDictionary(kvp => kvp.Key, kvp => kvp.Value);

// Performance considerations and optimization
// Deferred execution - query is not executed until enumeration
var deferredQuery = numbers.Where(n => n > 5).Select(n => n * 2);
// Query executes here when we enumerate
foreach (var result in deferredQuery)
{
    Console.WriteLine(result);
}

// Force immediate execution with ToList(), ToArray(), etc.
var immediateExecution = numbers.Where(n => n > 5).ToList();

// Avoid multiple enumeration
var expensiveQuery = employees.Where(e => IsExpensiveOperation(e));
var materializedResults = expensiveQuery.ToList(); // Execute once
var count = materializedResults.Count;
var firstItem = materializedResults.FirstOrDefault();

// Method chaining for complex operations
var result = employees
    .Where(e => e.Age > 25)                    // Filter
    .GroupBy(e => e.Department)                // Group
    .Where(g => g.Count() > 1)                 // Filter groups
    .OrderBy(g => g.Key)                       // Sort groups
    .Select(g => new                           // Project
    {
        Department = g.Key,
        EmployeeCount = g.Count(),
        AverageSalary = g.Average(e => e.Salary),
        HighestPaid = g.OrderByDescending(e => e.Salary).First()
    })
    .ToList();

// Parallel LINQ (PLINQ) for performance
var parallelResult = employees
    .AsParallel()
    .Where(e => IsExpensiveOperation(e))
    .Select(e => ProcessEmployee(e))
    .ToList();

// Helper methods
private static List<string> GetSkillsForEmployee(string employeeName)
{
    // Mock implementation
    return new List<string> { "C#", "LINQ", "SQL" };
}

private static bool IsExpensiveOperation(Person employee)
{
    // Simulate expensive operation
    System.Threading.Thread.Sleep(1);
    return employee.Age > 30;
}

private static string ProcessEmployee(Person employee)
{
    // Simulate processing
    return $"Processed: {employee.FirstName}";
}

// Real-world example: Data analysis
public class SalesAnalyzer
{
    public class Sale
    {
        public DateTime Date { get; set; }
        public string Product { get; set; }
        public decimal Amount { get; set; }
        public string Region { get; set; }
        public string SalesPerson { get; set; }
    }

    public void AnalyzeSales(List<Sale> sales)
    {
        // Monthly sales summary
        var monthlySales = sales
            .GroupBy(s => new { s.Date.Year, s.Date.Month })
            .Select(g => new
            {
                Year = g.Key.Year,
                Month = g.Key.Month,
                TotalSales = g.Sum(s => s.Amount),
                TransactionCount = g.Count(),
                AverageTransaction = g.Average(s => s.Amount)
            })
            .OrderBy(x => x.Year)
            .ThenBy(x => x.Month);

        // Top performers
        var topSalesPeople = sales
            .GroupBy(s => s.SalesPerson)
            .Select(g => new
            {
                SalesPerson = g.Key,
                TotalSales = g.Sum(s => s.Amount),
                TransactionCount = g.Count()
            })
            .OrderByDescending(x => x.TotalSales)
            .Take(5);

        // Regional analysis
        var regionalAnalysis = sales
            .GroupBy(s => s.Region)
            .Join(
                sales.GroupBy(s => s.Product),
                regional => 1, // Dummy key for cross join
                product => 1,  // Dummy key for cross join
                (regional, product) => new { Regional = regional, Product = product }
            )
            .Where(x => x.Regional.Any(r => x.Product.Any(p => r.Product == p.Key)))
            .Select(x => new
            {
                Region = x.Regional.Key,
                Product = x.Product.Key,
                Sales = x.Regional.Where(r => r.Product == x.Product.Key).Sum(r => r.Amount)
            });
    }
}