C# 12 и .NET 8: паттерны, коллекции и производительность

// .csproj настройка
/*
<PropertyGroup>
  <PublishAot>true</PublishAot>
  <SelfContained>true</SelfContained>
</PropertyGroup>
*/

// Ограничения AOT:
// 1. Нет JIT-компиляции
// 2. Ограниченный reflection
// 3. Требует явного указания используемых сборок

// Преимущества:
// 1. Быстрый запуск (< 50 мс)
// 2. Меньший размер дистрибутива
// 3. Защита кода (нативная компиляция)

// Атрибуты для AOT
[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Использует reflection")]
public class DynamicTypeLoader
{
    // Код требует JIT-компиляции
}

[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Использует trimming")]
public class ReflectiveComponent
{
    // Может быть обрезано при AOT
}

3.2. Улучшения производительности GC

3.2.1. Оптимизации сборщика мусора

// Конфигурация GC в .NET 8
// appsettings.json
/*
{
  "System.GC": {
    "ServerGC": true,
    "ConcurrentGC": true,
    "RetainVM": true
  }
}
*/

// Программная конфигурация
AppContext.SetSwitch("System.GC.Concurrent", true);
AppContext.SetSwitch("System.GC.Server", true);

// Новые API для управления памятью
GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect(2, GCCollectionMode.Optimized, blocking: false, compacting: true);

// Мониторинг использования памяти
var memoryInfo = GC.GetGCMemoryInfo();
Console.WriteLine($"Heap Size: {memoryInfo.HeapSizeBytes}");
Console.WriteLine($"Fragmentation: {memoryInfo.FragmentedBytes}");

// MemoryCache с ограничениями
using Microsoft.Extensions.Caching.Memory;

var cacheOptions = new MemoryCacheOptions
{
    SizeLimit = 1024 * 1024 * 100, // 100 MB
    CompactionPercentage = 0.2,
    ExpirationScanFrequency = TimeSpan.FromMinutes(5)
};

var cache = new MemoryCache(cacheOptions);

3.3. Улучшения в LINQ и коллекциях

3.3.1. Новые методы и оптимизации

// Новые методы в .NET 8
var numbers = Enumerable.Range(1, 100);

// CountBy - группировка с подсчетом
var countBy = numbers.CountBy(n => n % 3);
// [(0, 33), (1, 34), (2, 33)]

// AggregateBy - агрегация с ключами
var aggregateBy = numbers.AggregateBy(
    keySelector: n => n % 3,
    seed: 0,
    (sum, item) => sum + item
);

// Index - получение индекса в Where
var indexed = numbers.Where((n, index) => n % 2 == 0 && index % 3 == 0);

// ToDictionary с устранением дубликатов
var dict = numbers.ToDictionary(
    n => n.ToString(),
    n => n * 2,
    StringComparer.OrdinalIgnoreCase
);

// Chunk для пакетной обработки
foreach (var chunk in numbers.Chunk(10))
{
    ProcessBatch(chunk);
}

// TryGetNonEnumeratedCount - попытка получить Count без перечисления
if (numbers.TryGetNonEnumeratedCount(out int count))
{
    // Быстрое получение количества
}

// DistinctBy, ExceptBy, IntersectBy, UnionBy
var distinct = numbers.DistinctBy(n => n % 5);

Практические примеры и бенчмарки

4.1. Реальный пример: кэширование с Frozen коллекциями

public class CurrencyService
{
    private readonly FrozenDictionary<string, decimal> _exchangeRates;
    private readonly DateTime _lastUpdated;
    
    public CurrencyService()
    {
        // Загрузка данных из внешнего источника
        var rates = LoadExchangeRates();
        
        // Заморозка словаря для оптимального чтения
        _exchangeRates = rates.ToFrozenDictionary(
            keySelector: r => r.CurrencyCode,
            elementSelector: r => r.Rate,
            comparer: StringComparer.OrdinalIgnoreCase
        );
        
        _lastUpdated = DateTime.UtcNow;
    }
    
    public decimal Convert(string fromCurrency, string toCurrency, decimal amount)
    {
        // Быстрый доступ к замороженному словарю
        var fromRate = _exchangeRates[fromCurrency];
        var toRate = _exchangeRates[toCurrency];
        
        return amount * toRate / fromRate;
    }
    
    public bool IsCurrencySupported(string currencyCode)
    {
        // O(1) проверка благодаря perfect hashing
        return _exchangeRates.ContainsKey(currencyCode);
    }
    
    private IEnumerable<ExchangeRate> LoadExchangeRates()
    {
        // Имитация загрузки из БД/API
        return new[]
        {
            new ExchangeRate("USD", 1.00m),
            new ExchangeRate("EUR", 0.85m),
            new ExchangeRate("GBP", 0.73m),
            new ExchangeRate("JPY", 110.50m)
        };
    }
}

public record ExchangeRate(string CurrencyCode, decimal Rate);

4.2. Бенчмарк: сравнение производительности

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]
public class CollectionsBenchmark
{
    private readonly Dictionary<string, int> _dictionary;
    private readonly FrozenDictionary<string, int> _frozenDictionary;
    
    public CollectionsBenchmark()
    {
        var data = Enumerable.Range(1, 1000)
            .ToDictionary(i => $"key_{i}", i => i);
        
        _dictionary = data;
        _frozenDictionary = data.ToFrozenDictionary();
    }
    
    [Benchmark]
    public int DictionaryLookup()
    {
        int sum = 0;
        for (int i = 1; i <= 1000; i++)
        {
            if (_dictionary.TryGetValue($"key_{i}", out int value))
                sum += value;
        }
        return sum;
    }
    
    [Benchmark]
    public int FrozenDictionaryLookup()
    {
        int sum = 0;
        for (int i = 1; i <= 1000; i++)
        {
            if (_frozenDictionary.TryGetValue($"key_{i}", out int value))
                sum += value;
        }
        return sum;
    }
}

// Результаты бенчмарка:
// | Method                 | Mean     | Allocated |
// |-----------------------|----------|-----------|
// | DictionaryLookup      | 1.234 μs | 0 B       |
// | FrozenDictionaryLookup| 0.456 μs | 0 B       | (~2.7x быстрее)

4.3. Использование новых фич в ASP.NET Core

// Program.cs с использованием C# 12
var builder = WebApplication.CreateBuilder(args);

// Коллекции в конфигурации
string[] allowedOrigins = ["https://localhost:3000", "https://app.example.com"];
string[] adminEmails = ["admin@example.com", "superadmin@example.com"];

builder.Services.AddCors(options =>
{
    options.AddPolicy("Allowed", policy =>
    {
        policy.WithOrigins([..allowedOrigins])
              .AllowAnyMethod()
              .AllowAnyHeader();
    });
});

// Первичные конструкторы в сервисах
public class UserService(ILogger<UserService> logger, IUserRepository repository)
{
    public async Task<User> GetUserAsync(int id)
    {
        logger.LogInformation("Getting user {UserId}", id);
        return await repository.GetByIdAsync(id);
    }
}

// Minimal API с новым синтаксисом
var app = builder.Build();

app.MapGet("/users/{id}", async (int id, UserService service) =>
{
    var user = await service.GetUserAsync(id);
    return user is not null ? Results.Ok(user) : Results.NotFound();
});

app.MapPost("/process", async (ProcessRequest request) =>
{
    // Использование новых коллекций
    var results = new List<ProcessResult>();
    
    foreach (var item in request.Items)
    {
        var result = ProcessItem(item);
        results.Add(result);
    }
    
    return Results.Ok([..results]); // Collection expression
});

app.Run();

public record ProcessRequest(ProcessItem[] Items);
public record ProcessItem(string Name, int Value);
public record ProcessResult(string Name, bool Success, DateTime ProcessedAt);

Заключение

C# 12 и .NET 8 представляют собой сфокусированное обновление, которое приносит значительные улучшения в трех ключевых областях: выразительность кода, работа с коллекциями и общая производительность. Эти релизы демонстрируют зрелость платформы, где вместо добавления революционных возможностей разработчики получают тщательно проработанные улучшения, которые имеют немедленное практическое применение.

Для максимальной отдачи от этих обновлений рекомендуется постепенное внедрение: начать с использования первичных конструкторов и нового синтаксиса коллекций, затем проанализировать возможности применения Frozen коллекций для статических данных, и наконец, рассмотреть переход на AOT компиляцию для критичных к производительности микросервисов и нативных приложений.