Как улучшить производительно­сть приложений C#

var sw = Stopwatch.StartNew();
// Подозрительный код
sw.Stop();
Console.WriteLine($"Время выполнения: {sw.ElapsedMilliseconds} мс");

[Benchmark]
public void СтарыйМетод()
{
    // Исходная реализация
}
 
[Benchmark]
public void НовыйМетод()
{
    // Улучшенная версия
}

   for (int i = 0; i < 1000; i++)
   {
       var temp = new MyClass();
       // Работа с temp
   }

   var temp = new MyClass();
   for (int i = 0; i < 1000; i++)
   {
       temp.Reset(); // Сбрасываем состояние вместо создания нового объекта
       // Работа с temp
   }

   using (var connection = new SqlConnection(connectionString))
   {
       connection.Open();
       // Работа с соединением
   }
   // Здесь connection уже освобожден

   public class ОбъектныйПул<T> where T : class, new()
   {
       private readonly ConcurrentBag<T> _объекты = new ConcurrentBag<T>();
 
       public T ПолучитьОбъект()
       {
           if (_объекты.TryTake(out T элемент))
               return элемент;
           
           return new T();
       }
 
       public void ВернутьОбъект(T элемент)
       {
           _объекты.Add(элемент);
       }
   }

   // Вместо класса
   public struct Точка
   {
       public double X;
       public double Y;
   }

// Плохо - создает много временных строк
string результат = "";
for (int i = 0; i < 1000; i++)
{
    результат += $"Элемент {i}, ";
}
 
// Хорошо - минимизирует аллокации
var sb = new StringBuilder();
for (int i = 0; i < 1000; i++)
{
    sb.Append("Элемент ").Append(i).Append(", ");
}
string результат = sb.ToString();

string строка1 = "тест";
string строка2 = new string(new char[] {'т', 'е', 'с', 'т'});
string строка3 = string.Intern(строка2);
 
Console.WriteLine(ReferenceEquals(строка1, строка2)); // False
Console.WriteLine(ReferenceEquals(строка1, строка3)); // True

   // Лучше указать начальную ёмкость
   var list = new List<int>(10000);

byte[] большойМассив = new byte[1024];
Span<byte> первыеN = большойМассив.AsSpan(0, 512);
Span<byte> последниеN = большойМассив.AsSpan(512, 512);
 
// Работаем с частями массива без копирования
первыеN.Fill(0);

async Task ОбработатьДанныеAsync(Memory<byte> данные)
{
    // Асинхронная обработка без копирования данных
    await Task.Delay(100); // Имитация асинхронной работы
    
    // Доступ к данным через Span для эффективной обработки
    Span<byte> спан = данные.Span;
    for (int i = 0; i < спан.Length; i++)
    {
        спан[i] = (byte)(спан[i] * 2);
    }
}

Span<byte> буфер = stackalloc byte[1024]; // Выделение на стеке, без сборки мусора
 
using (FileStream файл = File.OpenRead("большой_файл.dat"))
{
    while (файл.Read(буфер) > 0)
    {
        // Обработка данных напрямую из буфера
    }
}

 
// Менее эффективно
if (коллекция.Count() > 0) { /* ... */ }
 
// Более эффективно
if (коллекция.Any()) { /* ... */ }

// Плохо - каждый вызов Where пересоздает последовательность
var результат1 = коллекция.Where(x => x > 10).Where(x => x < 20);
 
// Лучше - только одно перечисление
var результат2 = коллекция.Where(x => x > 10 && x < 20);

// Если запрос используется многократно, сохраните результат
var фильтрованныйСписок = коллекция.Where(x => ДорогаяПроверка(x)).ToList();
// Теперь используем фильтрованныйСписок многократно без повторного вычисления

// Медленнее
var элемент = коллекция.Where(x => x.Id == 5).FirstOrDefault();
 
// Быстрее
var элемент = коллекция.FirstOrDefault(x => x.Id == 5);

// Создаем запрос, но он не выполняется
var запрос = коллекция.Where(x => ОченьМедленныйМетод(x));
 
// Внимание! Запрос выполнится здесь, вызывая ОченьМедленныйМетод 
// для каждого элемента
foreach (var x in запрос) { /* ... */ }

// Вместо:
var клиенты = dbContext.Customers.ToList();
 
// Используйте проекцию:
var клиенты = dbContext.Customers
    .Select(c => new { c.Id, c.Name, c.Email })
    .ToList();

// Избегаем проблемы N+1 запросов
var заказы = dbContext.Orders
    .Include(o => o.Customer)
    .Include(o => o.OrderItems)
    .ToList();

var параметры = new SqlParameter("@CustomerId", customerId);
var результат = dbContext.Database.ExecuteSqlRaw(
    "EXECUTE dbo.GetCustomerOrders @CustomerId", 
    параметры);

// Вместо многократных вызовов SaveChanges
foreach (var item in items)
{
    dbContext.Items.Add(item);
    dbContext.SaveChanges(); // Плохо - каждый раз вызывает транзакцию
}
 
// Лучше - один вызов
foreach (var item in items)
{
    dbContext.Items.Add(item);
}
dbContext.SaveChanges(); // Одна транзакция

// Синхронный метод блокирует поток
public List<Order> GetOrders()
{
    return dbContext.Orders.ToList();
}
 
// Асинхронный освобождает поток во время ожидания
public async Task<List<Order>> GetOrdersAsync()
{
    return await dbContext.Orders.ToListAsync();
}

// Последовательное выполнение
var данные1 = await ПолучитьДанные1Async();
var данные2 = await ПолучитьДанные2Async();
 
// Параллельное выполнение
var задача1 = ПолучитьДанные1Async();
var задача2 = ПолучитьДанные2Async();
await Task.WhenAll(задача1, задача2);
var данные1 = задача1.Result;
var данные2 = задача2.Result;

private Dictionary<string, User> _кэшПользователей = new();
 
public ValueTask<User> ПолучитьПользователяAsync(string id)
{
    if (_кэшПользователей.TryGetValue(id, out var user))
    {
        // Возвращаем готовый результат без создания Task
        return new ValueTask<User>(user);
    }
    
    // Асинхронно получаем данные только если нет в кэше
    return new ValueTask<User>(ПолучитьИзБДAsync(id));
}

private IMemoryCache _кэш;
 
public Данные ПолучитьДанные(string ключ)
{
    if (!_кэш.TryGetValue(ключ, out Данные результат))
    {
        // Данных нет в кэше - получаем из источника
        результат = ПолучитьИзИсточника(ключ);
        
        // Сохраняем в кэше на 10 минут
        var опции = new MemoryCacheEntryOptions()
            .SetAbsoluteExpiration(TimeSpan.FromMinutes(10));
            
        _кэш.Set(ключ, результат, опции);
    }
    
    return результат;
}

private IDistributedCache _кэш;
 
public async Task<Данные> ПолучитьДанныеAsync(string ключ)
{
    // Пытаемся получить из кэша
    var кэшированноеЗначение = await _кэш.GetStringAsync(ключ);
    
    if (кэшированноеЗначение != null)
        return JsonSerializer.Deserialize<Данные>(кэшированноеЗначение);
    
    // Получаем из источника
    var результат = await ПолучитьИзИсточникаAsync(ключ);
    
    // Сохраняем в распределенном кэше
    await _кэш.SetStringAsync(
        ключ, 
        JsonSerializer.Serialize(результат),
        new DistributedCacheEntryOptions { 
            AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30) 
        }
    );
    
    return результат;
}

public class ObjectPool<T> where T : class, new()
{
    private readonly ConcurrentBag<T> _objects;
    private readonly Func<T> _objectGenerator;
    
    public ObjectPool(Func<T> objectGenerator = null)
    {
        _objects = new ConcurrentBag<T>();
        _objectGenerator = objectGenerator ?? (() => new T());
    }
    
    public T Get()
    {
        if (_objects.TryTake(out T item)) 
            return item;
            
        return _objectGenerator();
    }
    
    public void Return(T item)
    {
        _objects.Add(item);
    }
}

private readonly ObjectPool<StringBuilder> _stringBuilderPool = new();
 
public string СоздатьСложнуюСтроку()
{
    var sb = _stringBuilderPool.Get();
    try
    {
        sb.Clear(); // Сбрасываем состояние 
        // Используем StringBuilder для операций
        sb.Append("Сложный").Append("текст");
        return sb.ToString();
    }
    finally
    {
        _stringBuilderPool.Return(sb); // Возвращаем в пул
    }
}

// Структура: выделяется на стеке, не создает давление на сборщик мусора
public readonly struct Координата
{
    public readonly double X;
    public readonly double Y;
    
    public Координата(double x, double y)
    {
        X = x;
        Y = y;
    }
    
    public double ВычислитьРасстояние(Координата other)
    {
        double dx = X - other.X;
        double dy = Y - other.Y;
        return Math.Sqrt(dx * dx + dy * dy);
    }
}

// Без ref: структура копируется при передаче
public double РассчитатьЧто-то(БольшаяСтруктура структура) { /*...*/ }
 
// С ref: передача по ссылке
public double РассчитатьЧто-то(ref БольшаяСтруктура структура) { /*...*/ }
 
// С in: передача по ссылке, но с защитой от изменений 
public double РассчитатьЧто-то(in БольшаяСтруктура структура) { /*...*/ }

// Обычный доступ: повторное обращение к элементу массива
for (int i = 0; i < массив.Length; i++)
{
    массив[i] = массив[i] * 2;
}
 
// С ref: одно обращение, работа с ссылкой на элемент
for (int i = 0; i < массив.Length; i++)
{
    ref int item = ref массив[i];
    item = item * 2;
}

public bool СтрокаНачинаетсяС(string строка, string префикс)
{
    ReadOnlySpan<char> span = строка.AsSpan();
    ReadOnlySpan<char> префиксSpan = префикс.AsSpan();
    
    return span.StartsWith(префиксSpan);
}

// Без предварительного выделения: коллекция будет многократно 
// перераспределять внутренний массив
var список = new List<int>();
for (int i = 0; i < 10000; i++)
{
    список.Add(i);
}
 
// С предварительным выделением: одно выделение памяти
var эффективныйСписок = new List<int>(10000);
for (int i = 0; i < 10000; i++)
{
    эффективныйСписок.Add(i);
}

// Последовательная обработка
foreach (var item in items)
{
    ОбработатьЭлемент(item);
}
 
// Параллельная обработка
Parallel.ForEach(items, item =>
{
    ОбработатьЭлемент(item);
});

var задача1 = Task.Run(() => Вычислить1());
var задача2 = Task.Run(() => Вычислить2());
var задача3 = Task.Run(() => Вычислить3());
 
await Task.WhenAll(задача1, задача2, задача3);
 
var результат = задача1.Result + задача2.Result + задача3.Result;

var опции = new ParallelOptions
{
    MaxDegreeOfParallelism = Environment.ProcessorCount / 2
};
 
Parallel.ForEach(элементы, опции, элемент =>
{
    // Интенсивные вычисления
});

var результат = элементы
    .AsParallel()
    .Where(x => x.Стоимость > 1000)
    .Select(x => новыйРасчет(x))
    .ToList();

var потоки = new List<Thread>();
var результаты = new double[Environment.ProcessorCount];
 
for (int i = 0; i < Environment.ProcessorCount; i++)
{
    int индекс = i; // Важно создать локальную копию для потока
    var поток = new Thread(() =>
    {
        результаты[индекс] = СложныеРасчёты(индекс);
    });
    
    потоки.Add(поток);
    поток.Start();
}
 
foreach (var поток in потоки)
{
    поток.Join(); // Ожидаем завершения всех потоков
}
 
double итог = результаты.Sum();

public static Func<T, bool> СоздатьФильтрПоСвойству<T>(string имяСвойства, object значение)
{
    var параметр = Expression.Parameter(typeof(T), "x");
    var свойство = Expression.Property(параметр, имяСвойства);
    var константа = Expression.Constant(значение);
    var сравнение = Expression.Equal(свойство, константа);
    
    return Expression.Lambda<Func<T, bool>>(сравнение, параметр).Compile();
}
 
// Использование
var продукты = new List<Product>();
var фильтр = СоздатьФильтрПоСвойству<Product>("Категория", "Электроника");
var отфильтровано = продукты.Where(фильтр).ToList();

public static Func<TSource, TTarget> СоздатьМаппер<TSource, TTarget>()
    where TTarget : new()
{
    var исходныйПараметр = Expression.Parameter(typeof(TSource), "source");
    var целевойОбъект = Expression.New(typeof(TTarget));
    
    var привязки = new List<MemberBinding>();
    var свойстваИсточника = typeof(TSource).GetProperties();
    var свойстваЦели = typeof(TTarget).GetProperties();
    
    foreach (var свойствоЦели in свойстваЦели)
    {
        var совпадающееСвойство = свойстваИсточника
            .FirstOrDefault(s => s.Name == свойствоЦели.Name && 
                                s.PropertyType == свойствоЦели.PropertyType);
        
        if (совпадающееСвойство != null)
        {
            var доступКСвойству = Expression.Property(исходныйПараметр, совпадающееСвойство);
            var привязка = Expression.Bind(свойствоЦели, доступКСвойству);
            привязки.Add(привязка);
        }
    }
    
    var инициализация = Expression.MemberInit(целевойОбъект, привязки);
    return Expression.Lambda<Func<TSource, TTarget>>(инициализация, исходныйПараметр).Compile();
}

public float СложитьМассив(float[] массив)
{
    float сумма = 0;
    int i = 0;
    
    // Обрабатываем данные блоками, размер которых зависит от Vector<float>
    int счетчикВекторов = массив.Length / Vector<float>.Count;
    var векторнаяСумма = Vector<float>.Zero;
    
    for (; i < счетчикВекторов * Vector<float>.Count; i += Vector<float>.Count)
    {
        векторнаяСумма += new Vector<float>(массив, i);
    }
    
    // Суммируем элементы вектора
    for (int j = 0; j < Vector<float>.Count; j++)
    {
        сумма += векторнаяСумма[j];
    }
    
    // Обрабатываем оставшиеся элементы
    for (; i < массив.Length; i++)
    {
        сумма += массив[i];
    }
    
    return сумма;
}

public float СкалярноеПроизведение(float[] a, float[] b)
{
    if (a.Length != b.Length)
        throw new ArgumentException("Массивы должны быть одинаковой длины");
    
    float результат = 0;
    int i = 0;
    
    int счетчикВекторов = a.Length / Vector<float>.Count;
    var векторныйРезультат = Vector<float>.Zero;
    
    for (; i < счетчикВекторов * Vector<float>.Count; i += Vector<float>.Count)
    {
        var vecA = new Vector<float>(a, i);
        var vecB = new Vector<float>(b, i);
        векторныйРезультат += vecA * vecB;
    }
    
    for (int j = 0; j < Vector<float>.Count; j++)
    {
        результат += векторныйРезультат[j];
    }
    
    for (; i < a.Length; i++)
    {
        результат += a[i] * b[i];
    }
    
    return результат;
}

// Традиционный подход с Task
private Dictionary<string, User> _userCache = new();
 
public async Task<User> GetUserAsync(string id)
{
    if (_userCache.TryGetValue(id, out var user))
    {
        // Несмотря на синхронное получение, создаем Task<User>
        return user;
    }
    
    // Асинхронно загружаем из базы
    return await _userRepository.GetByIdAsync(id);
}
 
// Оптимизированный подход с ValueTask
public ValueTask<User> GetUserOptimizedAsync(string id)
{
    if (_userCache.TryGetValue(id, out var user))
    {
        // Возвращаем структуру без выделения в куче
        return new ValueTask<User>(user);
    }
    
    // Создаем ValueTask из Task только если нужна асинхронная операция
    return new ValueTask<User>(_userRepository.GetByIdAsync(id));
}

// Запустите проект с профилированием через меню:
// Debug -> Performance Profiler -> CPU Usage
// После завершения сеанса получите детальный отчет

[Benchmark]
public void СтарыйМетод()
{
    // Существующая реализация
}
 
[Benchmark]
public void ОптимизированныйМетод()
{
    // Улучшенная версия
}
 
// Запуск: BenchmarkRunner.Run<МойКласс>();

services.AddApplicationInsightsTelemetry();

var cpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
var memCounter = new PerformanceCounter(".NET CLR Memory", "# Bytes in all Heaps", Process.GetCurrentProcess().ProcessName);
 
while (true)
{
    Console.WriteLine($"CPU: {cpuCounter.NextValue()}%, Memory: {memCounter.NextValue() / 1024 / 1024}MB");
    Thread.Sleep(1000);
}

// Стандартная компиляция
var стандартныйДелегат = Expression.Lambda<Func<int, int>>(
    Expression.Add(Expression.Parameter(typeof(int), "x"), Expression.Constant(1))
).Compile();
 
// Быстрая компиляция
var быстрыйДелегат = Expression.Lambda<Func<int, int>>(
    Expression.Add(Expression.Parameter(typeof(int), "x"), Expression.Constant(1))
).CompileFast();

// Сериализация
byte[] bytes = MessagePackSerializer.Serialize(myObject);
 
// Десериализация
MyObject obj = MessagePackSerializer.Deserialize<MyObject>(bytes);

ReadOnlySpan<char> text = "Текст для обработки".AsSpan();
Span<char> buffer = stackalloc char[100];
 
for (int i = 0; i < text.Length; i++)
{
    buffer[i] = char.ToUpper(text[i]);
}

[Test]
public void MyMethod_ShouldNotCreateExcessiveObjects()
{
    var memoryCheckpoint = dotMemory.Check();
    
    MyMethod(); // Тестируемый метод
    
    dotMemory.Check(memory =>
    {
        // Проверяем, что метод не создал слишком много объектов
        var objectsCreated = memory.GetDifference(memoryCheckpoint)
            .GetNewObjects()
            .Count;
            
        Assert.Less(objectsCreated, 1000);
    });
}

public List<Product> GetProducts(ProductFilter filter)
{
    return _context.Products
        .Where(p => p.CategoryId == filter.CategoryId)
        .Where(p => p.Price >= filter.MinPrice)
        .Where(p => p.Price <= filter.MaxPrice)
        .Include(p => p.Supplier)
        .Include(p => p.Category)
        .Include(p => p.Reviews)
        .ToList();
}

public List<ProductDto> GetProducts(ProductFilter filter)
{
    return _context.Products
        .Where(p => 
            p.CategoryId == filter.CategoryId &&
            p.Price >= filter.MinPrice &&
            p.Price <= filter.MaxPrice)
        .Select(p => new ProductDto 
        {
            Id = p.Id,
            Name = p.Name,
            Price = p.Price,
            CategoryName = p.Category.Name,
            SupplierName = p.Supplier.Name,
            ReviewCount = p.Reviews.Count
        })
        .ToList();
}

private readonly IMemoryCache _cache;
 
public List<ProductDto> GetProducts(ProductFilter filter)
{
    string cacheKey = $"Products_{filter.CategoryId}_{filter.MinPrice}_{filter.MaxPrice}";
    
    if (!_cache.TryGetValue(cacheKey, out List<ProductDto> results))
    {
        results = _context.Products
            // Код запроса такой же, как выше
            .ToList();
            
        _cache.Set(cacheKey, results, TimeSpan.FromMinutes(10));
    }
    
    return results;
}

public Bitmap ApplyFilter(Bitmap original, FilterSettings settings)
{
    var result = new Bitmap(original.Width, original.Height);
    
    for (int y = 0; y < original.Height; y++)
    {
        for (int x = 0; x < original.Width; x++)
        {
            Color pixelColor = original.GetPixel(x, y);
            
            // Создание новых объектов для каждого пикселя
            var hslColor = new HSLColor(pixelColor);
            hslColor.Luminosity *= settings.Brightness;
            hslColor.Saturation *= settings.Saturation;
            
            result.SetPixel(x, x, hslColor.ToRgb());
        }
    }
    
    return result;
}

public unsafe Bitmap ApplyFilter(Bitmap original, FilterSettings settings)
{
    var result = new Bitmap(original.Width, original.Height);
    
    BitmapData originalData = original.LockBits(
        new Rectangle(0, 0, original.Width, original.Height),
        ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
        
    BitmapData resultData = result.LockBits(
        new Rectangle(0, 0, result.Width, result.Height),
        ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
    
    int bytesPerPixel = 4;
    int heightInPixels = originalData.Height;
    int widthInBytes = originalData.Width * bytesPerPixel;
    
    byte* ptrFirstOriginalPixel = (byte*)originalData.Scan0;
    byte* ptrFirstResultPixel = (byte*)resultData.Scan0;
    
    // Переиспользуемый объект для конвертации
    HSLColor hslColor = new HSLColor();
    
    for (int y = 0; y < heightInPixels; y++)
    {
        byte* currentOriginalLine = ptrFirstOriginalPixel + (y * originalData.Stride);
        byte* currentResultLine = ptrFirstResultPixel + (y * resultData.Stride);
        
        for (int x = 0; x < widthInBytes; x += bytesPerPixel)
        {
            // Получаем компоненты цвета
            byte blue = currentOriginalLine[x];
            byte green = currentOriginalLine[x + 1];
            byte red = currentOriginalLine[x + 2];
            byte alpha = currentOriginalLine[x + 3];
            
            // Переиспользуем один объект HSLColor
            hslColor.SetRgb(red, green, blue);
            hslColor.Luminosity *= settings.Brightness;
            hslColor.Saturation *= settings.Saturation;
            
            // Получаем модифицированные компоненты
            hslColor.GetRgb(out red, out green, out blue);
            
            // Записываем результат
            currentResultLine[x] = blue;
            currentResultLine[x + 1] = green;
            currentResultLine[x + 2] = red;
            currentResultLine[x + 3] = alpha;
        }
    }
    
    original.UnlockBits(originalData);
    result.UnlockBits(resultData);
    
    return result;
}

public class OrderProcessor
{
    private readonly object _lockObject = new object();
    private Dictionary<int, Order> _pendingOrders = new Dictionary<int, Order>();
    
    public void ProcessOrder(Order order)
    {
        lock (_lockObject)
        {
            _pendingOrders[order.Id] = order;
        }
        
        // Долгая обработка заказа
        ValidateOrder(order);
        CalculateTax(order);
        UpdateInventory(order);
        ProcessPayment(order);
        
        lock (_lockObject)
        {
            _pendingOrders.Remove(order.Id);
        }
    }
    
    public int GetPendingOrderCount()
    {
        lock (_lockObject)
        {
            return _pendingOrders.Count;
        }
    }
}

public class OrderProcessor
{
    private ConcurrentDictionary<int, Order> _pendingOrders = 
        new ConcurrentDictionary<int, Order>();
    
    public async Task ProcessOrderAsync(Order order)
    {
        _pendingOrders.TryAdd(order.Id, order);
        
        try
        {
            await ValidateOrderAsync(order);
            await CalculateTaxAsync(order);
            await UpdateInventoryAsync(order);
            await ProcessPaymentAsync(order);
        }
        finally
        {
            _pendingOrders.TryRemove(order.Id, out _);
        }
    }
    
    public int GetPendingOrderCount()
    {
        return _pendingOrders.Count;
    }
}

public async Task ProcessOrderAsync(Order order)
{
    _pendingOrders.TryAdd(order.Id, order);
    
    try
    {
        await ValidateOrderAsync(order);
        
        // Параллельное выполнение независимых операций
        var taxTask = CalculateTaxAsync(order);
        var inventoryTask = UpdateInventoryAsync(order);
        
        await Task.WhenAll(taxTask, inventoryTask);
        await ProcessPaymentAsync(order);
    }
    finally
    {
        _pendingOrders.TryRemove(order.Id, out _);
    }
}

public List<Product> ImportProducts(string xmlFilePath)
{
    var products = new List<Product>();
    
    var doc = XDocument.Load(xmlFilePath);
    var productNodes = doc.Descendants("Product");
    
    foreach (var node in productNodes)
    {
        products.Add(new Product
        {
            Id = int.Parse(node.Element("Id").Value),
            Name = node.Element("Name").Value,
            Price = decimal.Parse(node.Element("Price").Value),
            Description = node.Element("Description")?.Value,
            CategoryId = int.Parse(node.Element("CategoryId").Value)
        });
    }
    
    return products;
}

public async Task<List<Product>> ImportProductsAsync(string xmlFilePath)
{
    var products = new List<Product>();
    
    using (var reader = XmlReader.Create(xmlFilePath))
    {
        Product currentProduct = null;
        string currentElement = null;
        
        while (await reader.ReadAsync())
        {
            switch (reader.NodeType)
            {
                case XmlNodeType.Element:
                    if (reader.Name == "Product")
                    {
                        currentProduct = new Product();
                    }
                    else if (currentProduct != null)
                    {
                        currentElement = reader.Name;
                    }
                    break;
                
                case XmlNodeType.Text:
                    if (currentProduct != null && !string.IsNullOrEmpty(currentElement))
                    {
                        switch (currentElement)
                        {
                            case "Id":
                                currentProduct.Id = int.Parse(reader.Value);
                                break;
                            case "Name":
                                currentProduct.Name = reader.Value;
                                break;
                            case "Price":
                                currentProduct.Price = decimal.Parse(reader.Value);
                                break;
                            case "Description":
                                currentProduct.Description = reader.Value;
                                break;
                            case "CategoryId":
                                currentProduct.CategoryId = int.Parse(reader.Value);
                                break;
                        }
                    }
                    break;
                
                case XmlNodeType.EndElement:
                    if (reader.Name == "Product" && currentProduct != null)
                    {
                        products.Add(currentProduct);
                        currentProduct = null;
                    }
                    currentElement = null;
                    break;
            }
        }
    }
    
    return products;
}

public string SerializeProduct(Product product)
{
    return JsonConvert.SerializeObject(product, new JsonSerializerSettings
    {
        ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
        PreserveReferencesHandling = PreserveReferencesHandling.Objects
    });
}
 
public Product DeserializeProduct(string json)
{
    return JsonConvert.DeserializeObject<Product>(json, new JsonSerializerSettings
    {
        ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
        PreserveReferencesHandling = PreserveReferencesHandling.Objects
    });
}

// Создаем опции для многократного использования
private static readonly JsonSerializerOptions _options = new()
{
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
    WriteIndented = false
};
 
// Генерируем контекст сериализации один раз
[JsonSerializable(typeof(Product))]
[JsonSerializable(typeof(List<Product>))]
public partial class ProductSerializerContext : JsonSerializerContext
{
}
 
public string SerializeProduct(Product product)
{
    return System.Text.Json.JsonSerializer.Serialize(product, ProductSerializerContext.Default.Product);
}
 
public Product DeserializeProduct(string json)
{
    return System.Text.Json.JsonSerializer.Deserialize(json, ProductSerializerContext.Default.Product);
}

public Product FastDeserialize(ReadOnlySpan<byte> jsonData)
{
    var reader = new Utf8JsonReader(jsonData);
    var product = new Product();
    
    while (reader.Read())
    {
        if (reader.TokenType == JsonTokenType.PropertyName)
        {
            string propertyName = reader.GetString();
            reader.Read(); // Переходим к значению
            
            switch (propertyName)
            {
                case "id":
                    product.Id = reader.GetInt32();
                    break;
                case "name":
                    product.Name = reader.GetString();
                    break;
                case "price":
                    product.Price = reader.GetDecimal();
                    break;
                // И так далее для всех свойств
            }
        }
    }
    
    return product;
}

public class Program
{
    public static void Main()
    {
        // Инициализируем все модули при запуске
        var reportModule = new ReportModule();
        var analyticsModule = new AnalyticsModule();
        var exportModule = new ExportModule();
        var userManagementModule = new UserManagementModule();
        var dashboardModule = new DashboardModule();
        
        // Настраиваем и запускаем приложение
        var app = new Application(
            reportModule, 
            analyticsModule, 
            exportModule, 
            userManagementModule, 
            dashboardModule);
            
        app.Run();
    }
}

public class Application
{
    private readonly Dictionary<Type, Lazy<IModule>> _modules = new();
    
    public Application()
    {
        // Регистрируем модули с отложенной загрузкой
        RegisterModule<IReportModule>(() => new ReportModule());
        RegisterModule<IAnalyticsModule>(() => new AnalyticsModule());
        RegisterModule<IExportModule>(() => new ExportModule());
        RegisterModule<IUserManagementModule>(() => new UserManagementModule());
        RegisterModule<IDashboardModule>(() => new DashboardModule());
    }
    
    public void RegisterModule<T>(Func<T> factory) where T : IModule
    {
        _modules[typeof(T)] = new Lazy<IModule>(() => (IModule)factory());
    }
    
    public T GetModule<T>() where T : IModule
    {
        if (_modules.TryGetValue(typeof(T), out var lazyModule))
        {
            return (T)lazyModule.Value;
        }
        
        throw new KeyNotFoundException($"Module {typeof(T).Name} not found");
    }
    
    public void Run()
    {
        // Загружаем только необходимые модули для запуска
        var dashboardModule = GetModule<IDashboardModule>();
        dashboardModule.Initialize();
        
        // Остальные модули загрузятся по требованию
    }
}

public async Task InitializeAsync()
{
    // Запускаем асинхронную загрузку важных данных
    var userSettingsTask = LoadUserSettingsAsync();
    var recentFilesTask = LoadRecentFilesAsync();
    
    // Показываем интерфейс, не дожидаясь загрузки всех данных
    ShowMainWindow();
    
    // Ждем завершения загрузки в фоновом режиме
    await Task.WhenAll(userSettingsTask, recentFilesTask);
    
    // Обновляем интерфейс, когда данные готовы
    UpdateUI(await userSettingsTask, await recentFilesTask);
}

public List<PointOfInterest> FindNearbyPoints(double latitude, double longitude, double radiusKm)
{
    var result = new List<PointOfInterest>();
    
    foreach (var point in _allPoints)
    {
        // Вычисляем расстояние для каждой точки
        double distance = CalculateDistance(latitude, longitude, point.Latitude, point.Longitude);
        if (distance <= radiusKm)
        {
            result.Add(point);
        }
    }
    
    return result;
}
 
private double CalculateDistance(double lat1, double lon1, double lat2, double lon2)
{
    // Формула гаверсинусов для расчета расстояния между точками
    double R = 6371; // Радиус Земли в км
    double dLat = ToRadians(lat2 - lat1);
    double dLon = ToRadians(lon2 - lon1);
    
    double a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) +
               Math.Cos(ToRadians(lat1)) * Math.Cos(ToRadians(lat2)) *
               Math.Sin(dLon / 2) * Math.Sin(dLon / 2);
               
    double c = 2 * Math.Asin(Math.Sqrt(a));
    return R * c;
}
 
private double ToRadians(double degrees)
{
    return degrees * Math.PI / 180;
}

public class SpatialQuadTree
{
    private readonly QuadTreeNode _root;
    
    public SpatialQuadTree(List<PointOfInterest> points, BoundingBox bounds)
    {
        _root = new QuadTreeNode(bounds);
        
        foreach (var point in points)
        {
            _root.Insert(point);
        }
    }
    
    public List<PointOfInterest> QueryRange(double latitude, double longitude, double radiusKm)
    {
        // Преобразуем радиус в градусы (приблизительно)
        double radiusDegrees = radiusKm / 111.0; // ~111 км на градус
        
        var boundingBox = new BoundingBox
        {
            MinLat = latitude - radiusDegrees,
            MaxLat = latitude + radiusDegrees,
            MinLon = longitude - radiusDegrees,
            MaxLon = longitude + radiusDegrees
        };
        
        var candidatePoints = new List<PointOfInterest>();
        _root.QueryRange(boundingBox, candidatePoints);
        
        // Затем применяем точную проверку расстояния
        var result = new List<PointOfInterest>();
        foreach (var point in candidatePoints)
        {
            double distance = CalculateDistance(latitude, longitude, point.Latitude, point.Longitude);
            if (distance <= radiusKm)
            {
                result.Add(point);
            }
        }
        
        return result;
    }
}

private static class DistanceCalculator
{
    // Предрасчитанные константы для повышения производительности
    private const double EarthRadius = 6371.0; // км
    private const double ToRadCoef = Math.PI / 180.0;
    
    // Оптимизированная версия для приблизительного расчета
    public static double GetApproximateDistance(double lat1, double lon1, double lat2, double lon2)
    {
        // Для малых расстояний можем использовать упрощенную формулу
        double x = (lon2 - lon1) * ToRadCoef * Math.Cos(((lat1 + lat2) / 2) * ToRadCoef);
        double y = (lat2 - lat1) * ToRadCoef;
        
        return EarthRadius * Math.Sqrt(x * x + y * y);
    }
    
    // Точная формула для финального расчета
    public static double GetPreciseDistance(double lat1, double lon1, double lat2, double lon2)
    {
        double lat1Rad = lat1 * ToRadCoef;
        double lon1Rad = lon1 * ToRadCoef;
        double lat2Rad = lat2 * ToRadCoef;
        double lon2Rad = lon2 * ToRadCoef;
        
        double sinLat = Math.Sin((lat2Rad - lat1Rad) / 2);
        double sinLon = Math.Sin((lon2Rad - lon1Rad) / 2);
        
        double a = sinLat * sinLat +
                  Math.Cos(lat1Rad) * Math.Cos(lat2Rad) *
                  sinLon * sinLon;
                  
        double c = 2 * Math.Asin(Math.Min(1, Math.Sqrt(a)));
        
        return EarthRadius * c;
    }
}

public class SensorDataProcessor
{
    private List<SensorReading> _readings = new List<SensorReading>();
    
    public void AddReading(SensorReading reading)
    {
        _readings.Add(reading);
        
        // Вычисляем статистику при каждом добавлении
        CalculateStatistics();
    }
    
    private void CalculateStatistics()
    {
        double sum = 0;
        double min = double.MaxValue;
        double max = double.MinValue;
        
        foreach (var reading in _readings)
        {
            sum += reading.Value;
            min = Math.Min(min, reading.Value);
            max = Math.Max(max, reading.Value);
        }
        
        AverageValue = sum / _readings.Count;
        MinValue = min;
        MaxValue = max;
    }
    
    public double AverageValue { get; private set; }
    public double MinValue { get; private set; }
    public double MaxValue { get; private set; }
    
    public SensorReading[] GetReadingsForPeriod(DateTime start, DateTime end)
    {
        return _readings
            .Where(r => r.Timestamp >= start && r.Timestamp <= end)
            .OrderBy(r => r.Timestamp)
            .ToArray();
    }
}

public class OptimizedSensorDataProcessor
{
    // Используем структуру для хранения показаний, чтобы сэкономить память
    private struct CompactReading
    {
        public long TimestampTicks;
        public float Value;
    }
    
    // Круговой буфер фиксированного размера
    private readonly CompactReading[] _buffer;
    private int _head;
    private int _count;
    private readonly int _capacity;
    
    // Инкрементальная статистика
    private double _sum;
    private float _min = float.MaxValue;
    private float _max = float.MinValue;
    private long _totalReadings;
    
    public OptimizedSensorDataProcessor(int capacity)
    {
        _capacity = capacity;
        _buffer = new CompactReading[capacity];
    }
    
    public void AddReading(DateTime timestamp, float value)
    {
        // Обновляем статистику инкрементально
        _sum += value;
        _min = Math.Min(_min, value);
        _max = Math.Max(_max, value);
        _totalReadings++;
        
        // Определяем позицию для записи
        int index = (_head + _count) % _capacity;
        
        if (_count < _capacity)
        {
            _count++;
        }
        else
        {
            // Если буфер полон, вычитаем значение, которое будет перезаписано
            var oldReading = _buffer[_head];
            _sum -= oldReading.Value;
            _head = (_head + 1) % _capacity;
            
            // Если удаляется минимальное или максимальное значение, нужно пересчитать
            if (oldReading.Value == _min || oldReading.Value == _max)
            {
                RecalculateMinMax();
            }
        }
        
        // Сохраняем новое значение
        _buffer[index] = new CompactReading
        {
            TimestampTicks = timestamp.Ticks,
            Value = value
        };
    }
    
    private void RecalculateMinMax()
    {
        _min = float.MaxValue;
        _max = float.MinValue;
        
        for (int i = 0; i < _count; i++)
        {
            int index = (_head + i) % _capacity;
            _min = Math.Min(_min, _buffer[index].Value);
            _max = Math.Max(_max, _buffer[index].Value);
        }
    }
    
    public double AverageValue => _count > 0 ? _sum / _count : 0;
    public float MinValue => _min;
    public float MaxValue => _max;
    public long TotalReadings => _totalReadings;
    
    public ReadOnlySpan<SensorReading> GetReadingsForPeriod(DateTime start, DateTime end)
    {
        var result = new List<SensorReading>(_count);
        long startTicks = start.Ticks;
        long endTicks = end.Ticks;
        
        for (int i = 0; i < _count; i++)
        {
            int index = (_head + i) % _capacity;
            var reading = _buffer[index];
            
            if (reading.TimestampTicks >= startTicks && reading.TimestampTicks <= endTicks)
            {
                result.Add(new SensorReading
                {
                    Timestamp = new DateTime(reading.TimestampTicks),
                    Value = reading.Value
                });
            }
        }
        
        return CollectionsMarshal.AsSpan(result);
    }
}