Продвинутая обработка данных с LINQ в C#

var result = customers
    .Where(c => c.Orders.Any(o => o.Total > 1000))
    .SelectMany(c => c.Orders)
    .GroupBy(o => o.Date.Month)
    .Select(g => new { 
        Month = g.Key, 
        TotalAmount = g.Sum(o => o.Total),
        AverageAmount = g.Average(o => o.Total)
    })
    .OrderByDescending(x => x.TotalAmount);

var adultCustomers = new List<Customer>();
foreach (var customer in customers)
{
    if (customer.Age >= 18)
    {
        adultCustomers.Add(customer);
    }
}
 
adultCustomers.Sort((c1, c2) => string.Compare(c1.Name, c2.Name));

var adultCustomers = customers
    .Where(c => c.Age >= 18)
    .OrderBy(c => c.Name);

// Традиционый подход с XPath
var nodes = document.SelectNodes("//Order[@Status='Completed']/Items/Item[@Price > 100]");
// против элегантного LINQ to XML
var expensiveItems = document.Descendants("Order")
    .Where(o => (string)o.Attribute("Status") == "Completed")
    .Descendants("Item")
    .Where(i => (decimal)i.Attribute("Price") > 100);

// Определение запроса (еще ничего не вычисляется)
var query = collection.Where(x => ExpensiveOperation(x)).Select(x => x.Name);
 
// Вот здесь запрос реально выполняется
foreach (var item in query) { ... }

// Анти-паттерн: повторная материализация в цикле
foreach(var customer in customers)
{
var orders = customer.Orders.Where(o => o.IsActive).ToList(); // ToList заставляет выполнить запрос
// И дальше снова и снова для каждого клиента
}

// Лучше: однократная материализация
var activeOrders = customers.SelectMany(c => c.Orders).Where(o => o.IsActive).ToList();
// Или используем группировку
var customerOrderMap = customers.SelectMany(c => c.Orders)
.Where(o => o.IsActive)
.GroupBy(o => o.CustomerId)
.ToDictionary(g => g.Key, g => g.ToList());

// Медленно на больших коллекциях - O(n*m)
var matchingItems = listA.Where(a => listB.Contains(a)).ToList();
 
// Гораздо быстрее - почти O(n)
var setBForLookup = new HashSet<T>(listB);
var matchingItemsFast = listA.Where(a => setBForLookup.Contains(a)).ToList();

// Каждый раз создаётся новый делегат
items.Where(x => x.Status == Status.Active);
 
// Лучше: делегат создаётся один раз
Func<Item, bool> activeFilter = x => x.Status == Status.Active;
items.Where(activeFilter);

// Неоптимально: трансформация выполняется для всех элементов
collection.Select(x => ExpensiveTransform(x)).Where(x => x.IsValid);
 
// Гораздо эффективнее: сначала отфильтровать, потом трансформировать
collection.Where(x => IsLikelyValid(x)).Select(x => ExpensiveTransform(x));

// Вместо стандартного
var transactionsByAccount = transactions.ToLookup(t => t.AccountNumber);
 
// Использовали специализированную структуру
var fastLookup = new FastLookupCollection<string, Transaction>(transactions, t => t.AccountNumber);

// Может быть очень медленным на больших коллекциях
var uniqueCustomers = customers.Select(o => o.CustomerId).Distinct().ToList();
 
// Гораздо быстрее с предварительным выделением ёмкости
var uniqueSet = new HashSet<int>(customers.Select(o => o.CustomerId));

// Кошмар производительности - O(n*m)
var results = customers
    .SelectMany(c => orders.Where(o => o.CustomerId == c.Id)
        .SelectMany(o => orderDetails.Where(od => od.OrderId == o.Id)));
 
// Гораздо эффективнее с предварительной индексацией
var ordersByCustomer = orders.ToLookup(o => o.CustomerId);
var detailsByOrder = orderDetails.ToLookup(od => od.OrderId);
 
var efficientResults = customers
    .SelectMany(c => ordersByCustomer[c.Id]
        .SelectMany(o => detailsByOrder[o.Id]));

private static readonly ConcurrentDictionary<string, object> _queryCache 
    = new ConcurrentDictionary<string, object>();
 
public static IEnumerable<T> CachedQuery<T>(
    this IEnumerable<T> source, 
    Func<IEnumerable<T>, IEnumerable<R>> query,
    string cacheKey,
    TimeSpan? expiration = null)
{
    return _queryCache.GetOrAdd(cacheKey, _ => query(source).ToList());
}

// Последовательная обработка
var results = hugeCollection.Where(ExpensiveFilter).Select(ExpensiveTransform);
 
// Параллельная обработка
var parallelResults = hugeCollection.AsParallel()
    .Where(ExpensiveFilter)
    .Select(ExpensiveTransform);

// Это только рецепт — никаких вычислений не происходит
var query = customers
    .Where(c => c.Orders.Count > 10)
    .OrderBy(c => c.LastOrderDate)
    .Select(c => new { c.Name, OrderCount = c.Orders.Count });
 
// А вот здесь запрос действительно начинает выполняться
foreach (var item in query) { ... }

var baseQuery = customers.Where(c => c.IsActive);
 
// В зависимости от условий добавляем новые операции
if (hasRecentOrdersFilter)
{
    baseQuery = baseQuery.Where(c => c.LastOrderDate > DateTime.Now.AddMonths(-3));
}
 
var result = baseQuery.OrderBy(c => c.Name);

// Опасный код: запрос будет выполнен ДВАЖДЫ!
var query = expensiveData.Where(x => ComplexCalculation(x));
Console.WriteLine($"Found {query.Count()} items");
foreach (var item in query) { ... }

// Правильно: материализуем результат ОДИН раз
var materialized = expensiveData.Where(x => ComplexCalculation(x)).ToList();
Console.WriteLine($"Found {materialized.Count} items");
foreach (var item in materialized) { ... }

var minPrice = 100;
var query = products.Where(p => p.Price > minPrice);
 
// Изменяем переменную после определения запроса
minPrice = 200;
 
// Сюрприз! Фильтруются товары дороже 200, а не 100
foreach (var product in query) { ... }

// Анти-паттерн: возвращаем IQueryable
public IQueryable<Order> GetRecentOrders() 
{
    return _context.Orders.Where(o => o.Date > DateTime.Now.AddDays(-30));
}
 
// В клиентском коде:
var orders = service.GetRecentOrders(); // Запрос ещё не выполнен!
var count = orders.Count(); // Первый запрос к БД
var first = orders.FirstOrDefault(); // Второй запрос к БД
// ... и так далее

private static readonly ConcurrentDictionary<string, object> _queryCache 
= new ConcurrentDictionary<string, object>();
 
public static IEnumerable<T> WithCaching<T>(
    this IEnumerable<T> source, 
    string cacheKey,
    TimeSpan expiration) 
{
    if (_queryCache.TryGetValue(cacheKey, out var cachedResult))
    {
        return (IEnumerable<T>)cachedResult;
    }
    
    var result = source.ToList();
    _queryCache[cacheKey] = result;
    
    // Асинхронно планируем удаление устаревших данных
    Task.Delay(expiration).ContinueWith(_ => 
        _queryCache.TryRemove(cacheKey, out _));
    
    return result;
}

var expensiveResults = expensiveQuery.WithCaching("key1", TimeSpan.FromMinutes(15));

var cache = new MemoryCache(new MemoryCacheOptions());
 
public IEnumerable<T> GetOrCreateCache<T>(string key, Func<IEnumerable<T>> factory)
{
    return cache.GetOrCreate(key, entry => {
        entry.SetSlidingExpiration(TimeSpan.FromMinutes(30));
        entry.SetPriority(CacheItemPriority.High);
        return factory().ToList();
    });
}

var stopwatch = Stopwatch.StartNew();
var result = myComplexQuery.ToList();
stopwatch.Stop();
Console.WriteLine($"Query executed in {stopwatch.ElapsedMilliseconds}ms");

// Entity Framework Core
optionsBuilder.EnableSensitiveDataLogging()
             .LogTo(Console.WriteLine);

items.Where(i => i.CategoryId == categoryId)
     .OrderByDescending(i => i.LastUpdated)
     .Skip((page - 1) * pageSize)
     .Take(pageSize)

items.Where(i => i.CategoryId == categoryId)
     .OrderByDescending(i => i.LastUpdated)
     .Skip((page - 1) * pageSize)
     .Take(pageSize)
     .AsNoTracking() // Только для EF!

// Печально известный N+1 запрос
var problematicQuery = customers.Where(c => c.Orders.Any(o => o.Amount > 1000));

var eligiblePolicies = policies
    .Where(p => p.Status == PolicyStatus.Active)
    .Where(p => p.Coverages.Any(c => c.Type == CoverageType.Medical 
                                   && c.Options.Any(o => o.PremiumAmount > 500)))
    .Select(p => new PolicySummary
    {
        PolicyNumber = p.Number,
        CustomerName = p.Customer.FullName,
        TotalPremium = p.Coverages.Sum(c => c.PremiumAmount),
        HighRiskOptions = p.Coverages
            .SelectMany(c => c.Options)
            .Where(o => o.RiskFactor > 0.7)
            .Select(o => o.Name)
            .ToList()
    });

var salesAnalytics = sales
    .GroupBy(s => new { s.Region, s.ProductCategory, Month = s.Date.Month })
    .Select(g => new SalesMetrics
    {
        Region = g.Key.Region,
        Category = g.Key.ProductCategory,
        Month = g.Key.Month,
        TotalRevenue = g.Sum(s => s.Revenue),
        AverageOrderSize = g.Average(s => s.Revenue),
        OrderCount = g.Count(),
        TopProducts = g.GroupBy(s => s.ProductId)
                       .OrderByDescending(pg => pg.Sum(s => s.Revenue))
                       .Take(3)
                       .Select(pg => pg.Key)
                       .ToList()
    })
    .OrderByDescending(a => a.TotalRevenue);

// Запрос к базе через Entity Framework
var patients = context.Patients
    .Where(p => p.TrialGroup == trialGroupId)
    .Select(p => new { p.Id, p.Age, p.Gender })
    .ToList();
 
// Данные из XML
var xmlData = XDocument.Load("research_results.xml");
var measurements = xmlData.Descendants("measurement")
    .Select(m => new { 
        PatientId = (int)m.Attribute("patientId"),
        Date = (DateTime)m.Element("date"),
        Value = (decimal)m.Element("value")
    })
    .ToList();
 
// Данные из JSON
var jsonText = await httpClient.GetStringAsync("https://api.example.com/side-effects");
var sideEffects = JsonConvert.DeserializeObject<List<SideEffect>>(jsonText);
 
// Объединяем всё вместе
var report = patients
    .GroupJoin(
        measurements,
        p => p.Id,
        m => m.PatientId,
        (p, ms) => new { Patient = p, Measurements = ms }
    )
    .Select(x => new PatientReport
    {
        PatientId = x.Patient.Id,
        Demographics = $"{x.Patient.Age} лет, {x.Patient.Gender}",
        AverageMeasurement = x.Measurements.Average(m => m.Value),
        SideEffects = sideEffects
            .Where(se => se.PatientId == x.Patient.Id)
            .Select(se => se.Description)
            .ToList()
    });

IQueryable<Contract> query = context.Contracts;
 
if (!string.IsNullOrEmpty(searchParams.CustomerName))
{
    query = query.Where(c => c.Customer.Name.Contains(searchParams.CustomerName));
}
 
if (searchParams.MinAmount.HasValue)
{
    query = query.Where(c => c.TotalAmount >= searchParams.MinAmount.Value);
}
 
if (searchParams.MaxAmount.HasValue)
{
    query = query.Where(c => c.TotalAmount <= searchParams.MaxAmount.Value);
}
 
if (searchParams.ContractTypes?.Any() == true)
{
    query = query.Where(c => searchParams.ContractTypes.Contains(c.Type));
}
 
if (searchParams.SortBy == "Amount")
{
    query = searchParams.SortDirection == "ASC" 
        ? query.OrderBy(c => c.TotalAmount)
        : query.OrderByDescending(c => c.TotalAmount);
}
else
{
    query = searchParams.SortDirection == "ASC"
        ? query.OrderBy(c => c.StartDate)
        : query.OrderByDescending(c => c.StartDate);
}
 
var pagedResult = await query
    .Skip((searchParams.Page - 1) * searchParams.PageSize)
    .Take(searchParams.PageSize)
    .ToListAsync();

public class Category
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int? ParentId { get; set; }
    public List<Category> Children { get; set; } = new List<Category>();
}
 
public static List<Category> BuildTree(List<Category> allCategories)
{
    var lookup = allCategories.ToLookup(c => c.ParentId);
    
    foreach (var category in allCategories)
    {
        category.Children = lookup[category.Id].ToList();
    }
    
    return allCategories.Where(c => c.ParentId == null).ToList();
}

var report = transactions
    .GroupBy(t => new { Year = t.Date.Year, Month = t.Date.Month })
    .OrderBy(g => g.Key.Year).ThenBy(g => g.Key.Month)
    .Select(g => new MonthlyReport
    {
        Period = $"{g.Key.Year}-{g.Key.Month:D2}",
        TotalAmount = g.Sum(t => t.Amount),
        TransactionCount = g.Count(),
        CategoryBreakdown = g.GroupBy(t => t.Category)
            .Select(cg => new CategoryBreakdown
            {
                Category = cg.Key,
                Amount = cg.Sum(t => t.Amount),
                Percentage = cg.Sum(t => t.Amount) / g.Sum(t => t.Amount) * 100
            })
            .OrderByDescending(cb => cb.Amount)
            .ToList()
    })
    .ToList();

var anomalies = dataStream
    .Buffer(TimeSpan.FromMinutes(5), 100)
    .Select(buffer => new
    {
        Average = buffer.Average(reading => reading.Value),
        StdDev = Math.Sqrt(buffer.Average(r => Math.Pow(r.Value - buffer.Average(x => x.Value), 2)))
    })
    .Where(stats => stats.StdDev > threshold)
    .SelectMany(stats => stats.Buffer.Where(r => 
        Math.Abs(r.Value - stats.Average) > stats.StdDev * 2))
    .Subscribe(anomaly => AlertSystem.ReportAnomaly(anomaly));

public async Task<List<OrderWithDetails>> GetOrdersWithDetails(List<int> orderIds)
{
    // Получаем все заказы одним запросом
    var orders = await _orderRepository.GetOrdersByIds(orderIds);
    
    // Собираем все ID продуктов из всех заказов
    var productIds = orders
        .SelectMany(o => o.Items.Select(i => i.ProductId))
        .Distinct()
        .ToList();
    
    // Получаем все нужные продукты одним запросом
    var products = await _productService.GetProductsByIds(productIds);
    var productLookup = products.ToDictionary(p => p.Id);
    
    // Соединяем данные
    return orders.Select(o => new OrderWithDetails
    {
        Order = o,
        Items = o.Items.Select(i => new OrderItemWithDetails
        {
            Item = i,
            Product = productLookup.GetValueOrDefault(i.ProductId)
        }).ToList()
    }).ToList();
}

// Вместо блокирующего
var customers = dbContext.Customers
    .Where(c => c.Region == "North")
    .ToList();
 
// Используем асинхронный аналог
var customers = await dbContext.Customers
    .Where(c => c.Region == "North")
    .ToListAsync();

public async IAsyncEnumerable<TransactionData> GetLargeTransactionStreamAsync()
{
    using var connection = new SqlConnection(_connectionString);
    await connection.OpenAsync();
    
    using var command = new SqlCommand("SELECT * FROM Transactions WHERE Amount > 10000", connection);
    using var reader = await command.ExecuteReaderAsync();
    
    while (await reader.ReadAsync())
    {
        yield return new TransactionData
        {
            Id = reader.GetInt32(0),
            Amount = reader.GetDecimal(1),
            Date = reader.GetDateTime(2)
        };
    }
}

await foreach (var transaction in GetLargeTransactionStreamAsync())
{
    // Обрабатываем каждую транзакцию по мере поступления
    await ProcessTransactionAsync(transaction);
}

public async Task AnalyzeTransactionsAsync()
{
    var suspiciousTransactions = GetLargeTransactionStreamAsync()
        .WhereAwait(async t => await IsSuspiciousAsync(t))
        .Select(t => new Alert { TransactionId = t.Id, Amount = t.Amount })
        .OrderByDescending(a => a.Amount);
        
    await foreach (var alert in suspiciousTransactions)
    {
        _alertService.Register(alert);
        await _dashboardHub.SendAlertAsync(alert);
    }
}

// Установите пакет: Install-Package System.Linq.Async
using System.Linq.Async;
 
public async Task<decimal> CalculateRiskScoreAsync(int customerId)
{
    return await GetCustomerTransactionsAsync(customerId)
        .SelectAwait(async t => new { 
            Transaction = t, 
            RiskFactor = await _riskService.EvaluateAsync(t)
        })
        .AverageAsync(item => item.RiskFactor);
}

// Антипаттерн: слишком много параллельных запросов
var patientRisks = await patients
    .SelectAwait(async p => new {
        Patient = p,
        Risk = await _externalService.GetRiskScoreAsync(p.Id) // Boom!
    })
    .ToListAsync();

// Ограничиваем одновременные запросы
var throttler = new SemaphoreSlim(10); // Максимум 10 параллельных запросов
 
var patientRisks = await patients
    .ToAsyncEnumerable()
    .SelectAwait(async p => {
        await throttler.WaitAsync();
        try {
            return new {
                Patient = p,
                Risk = await _externalService.GetRiskScoreAsync(p.Id)
            };
        }
        finally {
            throttler.Release();
        }
    })
    .ToListAsync();

IObservable<SensorReading> sensorStream = GetSensorReadingsStream();
 
sensorStream
    .Buffer(TimeSpan.FromMinutes(1), 100)
    .Select(buffer => new {
        Average = buffer.Average(r => r.Value),
        Readings = buffer
    })
    .SelectMany(data => data.Readings
        .Where(r => Math.Abs(r.Value - data.Average) > threshold)
        .Select(r => new Anomaly(r.SensorId, r.Value, data.Average))
    )
    .Subscribe(
        anomaly => _alertManager.Notify(anomaly),
        ex => _logger.LogError(ex, "Error processing sensor data")
    );

public static class LinqExtensions
{
    public static IEnumerable<T> WhereNotNull<T>(this IEnumerable<T?> source) 
        where T : class
    {
        return source.Where(x => x != null).Cast<T>();
    }
    
    public static IEnumerable<TResult> DistinctBy<TSource, TKey>(
        this IEnumerable<TSource> source,
        Func<TSource, TKey> keySelector)
    {
        HashSet<TKey> knownKeys = new HashSet<TKey>();
        foreach (var element in source)
        {
            if (knownKeys.Add(keySelector(element)))
            {
                yield return element;
            }
        }
    }
}

var uniqueCustomers = orders.DistinctBy(o => o.CustomerId);
var validAddresses = customers.Select(c => c.ShippingAddress).WhereNotNull();

public static Expression<Func<T, bool>> Or<T>(
    this Expression<Func<T, bool>> expr1,
    Expression<Func<T, bool>> expr2)
{
    var parameter = Expression.Parameter(typeof(T));
    
    var leftVisitor = new ReplaceParameterVisitor(expr1.Parameters[0], parameter);
    var left = leftVisitor.Visit(expr1.Body);
    
    var rightVisitor = new ReplaceParameterVisitor(expr2.Parameters[0], parameter);
    var right = rightVisitor.Visit(expr2.Body);
    
    return Expression.Lambda<Func<T, bool>>(
        Expression.OrElse(left, right), parameter);
}
 
private class ReplaceParameterVisitor : ExpressionVisitor
{
    private readonly ParameterExpression _old;
    private readonly ParameterExpression _new;
    
    public ReplaceParameterVisitor(ParameterExpression old, ParameterExpression @new)
    {
        _old = old;
        _new = @new;
    }
    
    protected override Expression VisitParameter(ParameterExpression node)
    {
        return node == _old ? _new : base.VisitParameter(node);
    }
}

Expression<Func<Product, bool>> isFood = p => p.Category == "Food";
Expression<Func<Product, bool>> isExpensive = p => p.Price > 50;
 
var isExpensiveFood = isFood.Or(isExpensive);
var results = products.Where(isExpensiveFood);

public interface ISpecification<T>
{
    Expression<Func<T, bool>> Criteria { get; }
    bool IsSatisfiedBy(T entity);
}
 
public abstract class SpecificationBase<T> : ISpecification<T>
{
    public abstract Expression<Func<T, bool>> Criteria { get; }
    
    public bool IsSatisfiedBy(T entity)
    {
        return Criteria.Compile()(entity);
    }
    
    public static ISpecification<T> operator &(
        SpecificationBase<T> left, 
        SpecificationBase<T> right)
    {
        return new AndSpecification<T>(left, right);
    }
}
 
public class AndSpecification<T> : SpecificationBase<T>
{
    private readonly ISpecification<T> _left;
    private readonly ISpecification<T> _right;
    
    public AndSpecification(ISpecification<T> left, ISpecification<T> right)
    {
        _left = left;
        _right = right;
    }
    
    public override Expression<Func<T, bool>> Criteria
    {
        get
        {
            var param = Expression.Parameter(typeof(T), "x");
            
            var leftExpr = _left.Criteria;
            var rightExpr = _right.Criteria;
            
            var leftVisitor = new ParameterReplacer(leftExpr.Parameters[0], param);
            var rightVisitor = new ParameterReplacer(rightExpr.Parameters[0], param);
            
            var leftBody = leftVisitor.Visit(leftExpr.Body);
            var rightBody = rightVisitor.Visit(rightExpr.Body);
            
            var combinedBody = Expression.AndAlso(leftBody, rightBody);
            
            return Expression.Lambda<Func<T, bool>>(combinedBody, param);
        }
    }
}

public class ActiveCustomerSpecification : SpecificationBase<Customer>
{
    public override Expression<Func<Customer, bool>> Criteria => 
        c => c.Status == CustomerStatus.Active;
}
 
public class PremiumCustomerSpecification : SpecificationBase<Customer>
{
    public override Expression<Func<Customer, bool>> Criteria => 
        c => c.TotalSpent > 10000;
}
 
// Использование
var spec = new ActiveCustomerSpecification() & new PremiumCustomerSpecification();
var premiumActiveCustomers = repository.Find(spec);

var result = collection
.AsParallel()
.Where(item => ComplexCalculation(item))
.Select(item => new ResultModel(item))
.ToList();

// Опасно - результат непредсказуем
int sum = 0;
collection.AsParallel().ForAll(item => sum += item.Value);
 
// Правильно
int sum = collection.AsParallel().Sum(item => item.Value);

// Создаём пул геокодеров заранее
var geocoderPool = new ConcurrentBag<Geocoder>(
Enumerable.Range(0, Environment.ProcessorCount)
    .Select(_ => new Geocoder())
);
 
var results = addresses
.AsParallel()
.WithDegreeOfParallelism(Environment.ProcessorCount)
.Select(address => {
    // Берём геокодер из пула
    var geocoder = geocoderPool.TryTake(out var g) ? g : new Geocoder();
    try {
        return geocoder.Geocode(address);
    }
    finally {
        // Возвращаем в пул
        geocoderPool.Add(geocoder);
    }
})
.ToList();

IObservable<LogEvent> logStream = GetLogEventStream();
 
logStream
.Where(e => e.Severity >= LogSeverity.Warning)
.GroupBy(e => e.Source)
.SelectMany(group => group.Buffer(TimeSpan.FromMinutes(5))
    .Where(buffer => buffer.Count > 10)
    .Select(buffer => new AlertEvent(
        group.Key, 
        buffer.Count, 
        buffer.Max(e => e.Severity)
    ))
)
.Subscribe(
    alert => _alertService.Trigger(alert),
    ex => _logger.LogError(ex, "Error processing log events")
);

// MongoDB с официальным драйвером
var youngUsers = collection.AsQueryable()
.Where(u => u.Age < 30 && u.Status == "Active")
.OrderBy(u => u.LastName)
.Select(u => new { u.Id, u.FirstName, u.LastName, u.Email })
.ToList();

// Делаем базовую фильтрацию на стороне БД
var baseQuery = collection.AsQueryable()
.Where(x => x.Department == department && x.Date >= startDate);
 
// Загружаем в память и делаем сложную обработку на клиенте
var results = baseQuery.ToList()
.AsParallel()
.GroupBy(x => new { Month = x.Date.Month, Category = x.Category })
.Select(g => new AnalyticsResult {
    Month = g.Key.Month,
    Category = g.Key.Category,
    CustomMetric = CalculateComplexMetric(g)
})
.OrderByDescending(r => r.CustomMetric)
.Take(10)
.ToList();

public static class MyLinqExtensions
{
    public static IEnumerable<T> TakeLast<T>(this IEnumerable<T> source, int count)
    {
        if (source == null) throw new ArgumentNullException(nameof(source));
        if (count < 0) throw new ArgumentOutOfRangeException(nameof(count));
        
        if (count == 0) return Enumerable.Empty<T>();
        
        var queue = new Queue<T>(count);
        
        foreach (var item in source)
        {
            if (queue.Count == count)
                queue.Dequeue();
            
            queue.Enqueue(item);
        }
        
        return queue;
    }
}

var lastFiveOrders = customer.Orders
    .Where(o => o.Status == OrderStatus.Completed)
    .TakeLast(5);

public interface IRepository<T>
{
    IQueryable<T> Query { get; }
    IEnumerable<T> Find(Expression<Func<T, bool>> predicate);
}

public static class PredicateBuilder
{
    public static Expression<Func<T, bool>> And<T>(
        this Expression<Func<T, bool>> left,
        Expression<Func<T, bool>> right)
    {
        var parameter = Expression.Parameter(typeof(T));
        
        var leftVisitor = new ParameterReplacer(left.Parameters[0], parameter);
        var rightVisitor = new ParameterReplacer(right.Parameters[0], parameter);
        
        var leftBody = leftVisitor.Visit(left.Body);
        var rightBody = rightVisitor.Visit(right.Body);
        
        var body = Expression.AndAlso(leftBody, rightBody);
        
        return Expression.Lambda<Func<T, bool>>(body, parameter);
    }
    
    private class ParameterReplacer : ExpressionVisitor
    {
        private readonly ParameterExpression _old;
        private readonly ParameterExpression _new;
        
        public ParameterReplacer(ParameterExpression old, ParameterExpression @new)
        {
            _old = old;
            _new = @new;
        }
        
        protected override Expression VisitParameter(ParameterExpression node)
        {
            return node == _old ? _new : base.VisitParameter(node);
        }
    }
}

// В модуле аналитики
Expression<Func<Transaction, bool>> isLarge = t => t.Amount > 1000;
 
// В модуле безопастности
Expression<Func<Transaction, bool>> isInternational = t => t.Country != "US";
 
// В обработчике заказов
Expression<Func<Transaction, bool>> isRecent = t => t.Date > DateTime.Now.AddDays(-7);
 
// Комбинируем на лету
var riskFilter = isLarge.And(isInternational).And(isRecent);
var riskyTransactions = repository.Find(riskFilter);

public static IOrderedQueryable<T> OrderByProperty<T>(
    this IQueryable<T> source, 
    string propertyName, 
    bool descending = false)
{
    var type = typeof(T);
    var property = type.GetProperty(propertyName);
    
    if (property == null)
        throw new ArgumentException($"Property {propertyName} not found on type {type.Name}");
    
    var parameter = Expression.Parameter(type, "x");
    var propertyAccess = Expression.Property(parameter, property);
    var lambda = Expression.Lambda(propertyAccess, parameter);
    
    var methodName = descending ? "OrderByDescending" : "OrderBy";
    var methodCallExpression = Expression.Call(
        typeof(Queryable), 
        methodName,
        new[] { type, property.PropertyType },
        source.Expression, 
        Expression.Quote(lambda));
    
    return (IOrderedQueryable<T>)source.Provider.CreateQuery<T>(methodCallExpression);
}

// Поток из 100+ ГБ логов обрабатывается без загрузки в память
var anomalies = GetLogStream()
    .Where(log => log.Type == LogType.Error)
    .Window(TimeSpan.FromMinutes(5))
    .Where(window => window.Count() > threshold)
    .Select(window => new AnomalyEvent(window));