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

public int Sum(int y)
{
    Func<int, int> addY = x => x + y;
    return DoubleResult(addY, y);
}
 
private int DoubleResult(Func<int, int> func, int arg)
{
    int result = func(arg);
    return result + result;
}

void Process(string[] inputs)
{
    foreach (string input in inputs)
    {
        // Что-то делаем с input
    }
}
 
// Вызов
Process(new string[] { "a", "b", "c" });

// Было
GCHandle handle = GCHandle.Alloc(myArray, GCHandleType.Pinned);
try
{
    // Использование pinned объекта
}
finally
{
    handle.Free();
}
 
// Стало
using (new PinnedGCHandle<byte[]>(myArray))
{
    // Использование pinned объекта
}

class ResourceWrapper : IDisposable
{
    private IntPtr _nativeResource;
    
    public ResourceWrapper()
    {
        _nativeResource = AllocateNativeResource();
    }
    
    ~ResourceWrapper() // Финализатор
    {
        Dispose(false);
    }
    
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    
    protected virtual void Dispose(bool disposing)
    {
        if (_nativeResource != IntPtr.Zero)
        {
            FreeNativeResource(_nativeResource);
            _nativeResource = IntPtr.Zero;
        }
    }
}

// В .NET 9 этот код вызывал аллокацию в куче
Stopwatch sw = Stopwatch.StartNew();
// Измеряемый код
sw.Stop();
TimeSpan elapsed = sw.Elapsed;
 
// В .NET 10 аллокации нет!

bool IsFollowedByPeriod(string start, string text) =>
    start.Length < text.Length && text[start.Length] == '.';

ReadOnlySpan<byte> log2ToPow10 =
[
    1, 1, 1, 2, 2, 2, 3, 3, 3, 4, /* и т.д. */
];
return log2ToPow10[(int)ulong.Log2(value)];

bool StartAndEndAreSame(int[] ids) => ids[0] == ids[^1];

int[] arr = _arr;
for (int i = 0; i < count; i++)
{
    arr[i] = i;
}

static int Sum(IEnumerable<int> values)
{
    int sum = 0;
    foreach (int value in values)
    {
        sum += value;
    }
    return sum;
}

private static void M(object o)
{
    Monitor.Enter(o);
    try
    {
    }
    finally
    {
        Monitor.Exit(o);
    }
}

string Test(string s)
{
    s ??= "";
    return s.AsSpan();
}

public static JsonDocument Parse(string json)
{
    try
    {
        return FastParser.TryParse(json, out var doc)
            ? doc
            : SlowFallbackParser.Parse(json);
    }
    catch (JsonException)
    {
        throw;
    }
    catch (Exception ex)
    {
        throw new JsonException("Failed to parse JSON", ex);
    }
}

// Пример настройки режима быстрого старта
var builder = WebApplication.CreateBuilder(args);
builder.WebHost.ConfigureServices(services =>
{
    services.Configure<RuntimeOptions>(options =>
    {
        options.StartupMode = StartupMode.Fast;
    });
});

// В .NET 9 этот код приводил к многократным перестроениям метаданных
var properties = typeof(MyClass).GetProperties();
foreach (var prop in properties)
{
    prop.GetValue(instance);
}
 
// В .NET 10 метаданные строятся только один раз

// В .NET 9 этот код был довольно медленным при множественных вызовах
var type = Type.GetType("System.Collections.Generic.Dictionary`2[[System.String, System.Private.CoreLib],[System.Int32, System.Private.CoreLib]]");
 
// В .NET 10 последующие вызовы значительно быстрее

// Пример включения профилирования JIT-оптимизаций
using var session = new EventPipeSession();
session.EnableProvider("Microsoft-Windows-DotNETRuntime", EventLevel.Verbose,
    (long)ClrTraceEventParser.Keywords.JitTracing | (long)ClrTraceEventParser.Keywords.JitOptimization);

public void ProcessItem(Item item)
{
    lock (_syncObj)
    {
        // Обработка item
    }
}

private volatile object _instance;
private readonly object _lock = new object();
 
public object GetInstance()
{
    if (_instance == null)
    {
        lock (_lock)
        {
            if (_instance == null)
            {
                _instance = new object();
            }
        }
    }
    return _instance;
}

public class WeatherForecast
{
    public DateTime Date { get; set; }
    public int TemperatureC { get; set; }
    public string Summary { get; set; }
}
 
// Десериализация в .NET 10 стала заметно быстрее
var forecasts = JsonSerializer.Deserialize<WeatherForecast[]>(jsonString);

// Значительно ускорены операции форматирования
int number = 12345;
string formatted = number.ToString("N0"); // В .NET 10 работает быстрее на ~40%
 
// Оптимизирована работа с датами
DateTime now = DateTime.Now;
string isoDate = now.ToString("o"); // Ускорение на ~25%

// Новые замороженные коллекции обеспечивают максимальную производительность
// для сценариев "создай один раз, читай много раз"
var frozenSet = FrozenSet.Create(new[] { 1, 2, 3, 4, 5 });
bool contains = frozenSet.Contains(3); // Сверхбыстрая операция поиска

BitArray bits1 = new BitArray(10000);
BitArray bits2 = new BitArray(10000);
 
// Заполняем массивы...
 
// Эта операция теперь выполняется в несколько раз быстрее
bits1.Or(bits2);

// В .NET 9 это создавало временный массив
list.CopyTo(0, array, 0, 100);
 
// В .NET 10 можно работать напрямую со Span
list.CopyTo(list.AsSpan(0, 100), array.AsSpan(0, 100));

// Значительно ускорены цепочки операторов
var result = collection
    .Where(x => x.IsValid)
    .OrderBy(x => x.Priority)
    .Select(x => x.Name)
    .ToList();

// HttpClient теперь эффективнее обрабатывает повторные запросы
using var client = new HttpClient();
for (int i = 0; i < 1000; i++)
{
    var response = await client.GetAsync("https://example.com/api/data");
    // Обработка ответа...
}

// Новый низкоуровневый API для веб-сокетов
using var ws = new WebSocket("wss://example.com/socket");
await ws.ConnectAsync();
 
// Отправка данных с минимальными аллокациями
await ws.SendAsync(data.AsSpan(), WebSocketMessageType.Binary, true, CancellationToken.None);

// Оптимизированное чтение файлов небольшими блоками
await using var fileStream = new FileStream("large.dat", FileMode.Open);
var buffer = new byte[8192];
int bytesRead;
 
while ((bytesRead = await fileStream.ReadAsync(buffer)) > 0)
{
    // Обработка данных...
}

// Новый API для быстрой записи в файл
using var writer = new FastFileWriter("output.dat");
await writer.WriteAsync(data.AsSpan());

// В .NET 9 это создавало несколько временных строк
string fullPath = Path.Combine(baseDir, subDir, fileName);
 
// В .NET 10 добавлены Span-версии
Span<char> buffer = stackalloc char[260]; // MAX_PATH
if (Path.TryCombine(baseDir.AsSpan(), subDir.AsSpan(), fileName.AsSpan(), buffer, out int charsWritten))
{
    // Использование пути без аллокаций
}

// Ускоренные хеш-функции
using var sha256 = SHA256.Create();
byte[] hash = sha256.ComputeHash(data);

// Более эффективная работа с сертификатами
using var cert = new X509Certificate2(certBytes);
bool isValid = cert.Verify(); // Ускоренная проверка

// Создаём набор поисковых значений один раз
SearchValues<char> delimiters = SearchValues.Create(new[] { ',', ';', '\t', '|' });
 
// Используем для быстрого поиска любого из этих символов
int position = text.AsSpan().IndexOfAny(delimiters);

// Этот код в .NET 10 работает до 3 раз быстрее для сложных выражений
var regex = new Regex(@"\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b", RegexOptions.IgnoreCase);
var matches = regex.Matches(input);

// Новые оптимизированные методы поиска
ReadOnlySpan<char> text = "Это пример текста для поиска";
bool contains = text.Contains("пример", StringComparison.OrdinalIgnoreCase); // Быстрее на ~40%
 
// Эффективное разделение строки без аллокаций
foreach (var part in text.Split(' '))
{
    // Обработка части без создания временных строк
}

// В .NET 9 это создавало временную строку при каждом вызове
items.FirstOrDefault(s => s.StartsWith("prefix"));
 
// В .NET 10 с новыми перегрузками аллокаций нет
items.FirstOrDefault(s => s.AsSpan().StartsWith("prefix"));

// Новые высокопроизводительные примитивы
using var semaphore = new AsyncSemaphoreSlim(1);
await semaphore.WaitAsync(); // До 2 раз быстрее чем SemaphoreSlim
try
{
    // Критическая секция
}
finally
{
    semaphore.Release();
}

// Метод с настраиваемым AsyncMethodBuilder
[AsyncMethodBuilder(typeof(AsyncValueTaskMethodBuilder<>))]
public async ValueTask<int> GetValueAsync()
{
    await Task.Delay(100);
    return 42;
}

// Выполнение вычислений на GPU с помощью новых API
using var computeContext = ComputeContext.Create(ComputeDeviceType.Gpu);
var result = await computeContext.ExecuteAsync<float[]>(
    "matrixMultiply",
    new[] { matrixA, matrixB },
    new ComputeExecutionOptions { PreferredThreadCount = 256 }
);

// Эффективная работа с многомерными данными
var tensor = new Tensor<float>(new[] { 2, 3, 4 }); // 2x3x4 тензор
tensor.Fill(1.0f);
var result = Tensor.MatMul(tensorA, tensorB); // Оптимизированное матричное умножение

// Новый API для высокоточного измерения производительности
using var benchmark = PerformanceBenchmark.Start("CriticalOperation");
// Выполнение операции...
benchmark.Stop();
Console.WriteLine(benchmark.ElapsedMicroseconds); // Микросекундная точность

// Анализ потенциальных утечек
using var tracker = new MemoryLeakTracker();
// Выполнение подозрительного кода...
var leaks = tracker.GetPotentialLeaks();
foreach (var leak in leaks)
{
    Console.WriteLine($"Потенциальная утечка: {leak.Type}, количество: {leak.Count}");
}

// Высокопроизводительный канал для IPC
using var channel = new MemoryMappedChannel("MyChannel", 1024 * 1024);
await channel.WriteAsync(data.AsMemory());
 
// На другой стороне
using var receiverChannel = MemoryMappedChannel.Connect("MyChannel");
var receivedData = await receiverChannel.ReadAsync(buffer);

// Распределённый кэш между процессами
using var cache = DistributedCache.Create("SharedCache");
cache.Set("key", complexObject, TimeSpan.FromMinutes(10));
 
// В другом процессе
var value = cache.Get<ComplexObject>("key");

// Быстрое хеширование строк для словарей
var hashCode = StringHash.ComputeFast(key);
 
// Эффективная работа с большими числами
var result = BigIntegerAlgorithms.FastMultiply(a, b); // Использует алгоритм Карацубы

// dotnet run -c Release -f net9.0 --filter "*" --runtimes net9.0 net10.0
 
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
 
BenchmarkSwitcher.FromAssembly(typeof(Tests).Assembly).Run(args);
 
[MemoryDiagnoser(displayGenColumns: false)]
[HideColumns("Job", "Error", "StdDev", "Median", "RatioSD")]
public partial class Tests
{
    [Benchmark]
    public void Test()
    {
        // Тестируемый код
    }
}

public class WeatherForecast
{
    public DateTime Date { get; set; }
    public int TemperatureC { get; set; }
    public string Summary { get; set; }
}
 
[Benchmark]
public string SerializeJson()
{
    var forecasts = Enumerable.Range(1, 100)
        .Select(i => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(i),
            TemperatureC = Random.Shared.Next(-20, 55),
            Summary = "Test"
        })
        .ToArray();
    
    return JsonSerializer.Serialize(forecasts);
}

[Benchmark]
public int ProcessCollection()
{
    return Enumerable.Range(0, 10000)
        .Where(x => x % 2 == 0)
        .Select(x => x * 2)
        .Sum();
}

[Benchmark]
public async Task<int> AsyncProcessing()
{
    var tasks = Enumerable.Range(0, 100)
        .Select(i => Task.Run(() => i * i))
        .ToArray();
    
    return (await Task.WhenAll(tasks)).Sum();
}