Форум программистов, компьютерный форум, киберфорум
UnmanagedCoder
Войти
Регистрация
Восстановить пароль
Блоги Сообщество Поиск  

Что нового в .NET 10

Запись от UnmanagedCoder размещена 10.03.2025 в 11:25
Показов 5867 Комментарии 0
Метки .net, .net 10

Нажмите на изображение для увеличения
Название: 4faf9886-8476-4236-9fb3-cc387191ea6f.jpg
Просмотров: 287
Размер:	145.2 Кб
ID:	10356
.NET 10 выходит как релиз с длительной поддержкой (LTS), включающей три года обновлений. В этом обновлении Microsoft сфокусировались на нескольких направлениях: производительность, оптимизация памяти, улучшение кроссплатформенности и расширение возможностей языка C#.

Одним из наиболее значимых изменений .NET 10 является снижение накладных расходов абстракции в коде. Это значит, что разработчики могут писать высокоуровневый код, который работает почти так же быстро, как низкоуровневый. JIT-компилятор получил значительные улучшения, позволяющие девиртуализировать вызовы методов интерфейса массива и выделять небольшие массивы значимых типов прямо в стеке. .NET 10 также предлагает значительные улучшения в работе с сертификатами, JSON-сериализацией и обработкой архивов. SDK претерпел изменения, которые упрощают управление зависимостями и сокращают размер проектов. ASP.NET Core 10 существенно улучшает работу с Blazor, SignalR и Minimal API, а также добавляет поддержку OpenAPI 3.1, что делает документацию API более точной и лучше структурированной. MAUI продолжает развиваться, предлагая улучшения как для мобильных платформ, так и для десктопных приложений. Entity Framework Core также был оптимизирован, особенно в переводе LINQ-запросов и выполнении обновлений базы данных.

Производительность и оптимизация



Всем нравится, когда ПО работает быстро и Microsoft это понимает (наверно), поэтому в .NET 10 производительность стала одной из основных частей обновления.

Девиртуализация методов интерфейса массива



Одно из наиболее полезных улучшений касается работы со стандартными коллекциями. JIT-компилятор в .NET 10 теперь умеет девиртуализировать вызовы методов интерфейса при работе с массивами. На практике это означает, что код, использующий абстракции вроде IEnumerable<T>, теперь может выполняться почти так же быстро, как и прямые операции с массивами. До этого при использовании foreach для перебора массива через интерфейс IEnumerable<int> создавались виртуальные вызовы, которые препятствовали таким оптимизациям, как встраивание функций и устранение проверок границ:

C#
1
2
3
4
5
6
7
8
9
10
11
static int Sum(int[] array)
{
    int sum = 0;
    IEnumerable<int> temp = array;
    
    foreach (var num in temp)
    {
        sum += num;
    }
    return sum;
}
Теперь же JIT распознаёт, что за интерфейсом скрывается массив, и генерирует код почти такой же эффективный, как при прямой работе с массивом. Хорошая попытка по устранению "штрафа за абстракцию", на который годами жаловались разработчики высокопроизводительных приложений.

Стековое размещение массивов значимых типов



Еще одно улучшение — возможность размещать в стеке небольшие массивы, содержащие значимые типы. В предыдущих версиях .NET даже крошечный массив из трёх целых чисел всегда выделялся в куче, что создавало дополнительную нагрузку на сборщик мусора:

C#
1
2
3
4
5
6
7
8
9
10
11
12
static void Sum()
{
    int[] numbers = { 1, 2, 3 };
    int sum = 0;
    
    for (int i = 0; i < numbers.Length; i++)
    {
        sum += numbers[i];
    }
    
    Console.WriteLine(sum);
}
В .NET 10 JIT-компилятор анализирует такой код и видит, что массив numbers имеет фиксированный размер и не выходит за пределы метода Sum(), поэтому размещает его прямо в стеке. Это не только снижает нагрузку на сборщик мусора, но и улучшает локальность данных в кэше процессора, что может дать дополнительный прирост производительности.

Поддержка AVX10.2



.NET 10 добавляет также поддержку набора инструкций Advanced Vector Extensions (AVX) 10.2 для процессоров x64. Хотя на момент выхода .NET 10 оборудование с поддержкой AVX10.2 ещё не доступно, фреймворк уже готов использовать эти инструкции для ускорения векторных вычислений. Это открывает новые возможности в области высокопроизводительных вычислений, обработки графики и машинного обучения. Как только соответствующее железо появится на рынке, код на .NET сможет автоматически использовать преимущества новых инструкций SIMD (Single Instruction, Multiple Data).

Нативная компиляция (Native AOT)



Native AOT (Ahead-of-Time) компиляция значительные улучшена в .NET 10. Эта технология позволяет превратить .NET-код в нативный исполняемый файл для конкретной платформы ещё на этапе сборки проекта, минуя JIT-компиляцию во время выполнения. В .NET 10 расширена поддержка фреймворка для Native AOT и теперь она включает больше API и библиотек. Скорость запуска и потребление памяти приложений скомпилированных с помощью Native AOT теперь значительно лучше, а список поддерживаемых сценариев расширен.

Особенно впечатляющие результаты Native AOT показывает в контейнеризированных микросервисах, где быстрый запуск и низкое потребление памяти критически важны. Приложения, построенные с использованием минимального API ASP.NET Core и скомпилированные через Native AOT, могут стартовать почти мгновенно и потреблять в несколько раз меньше памяти по сравнению с традиционными подходами.

Улучшения в сборке мусора



Сборщику мусора (Garbage Collector, GC) также отсыпали оптимизаций в .NET 10. Одним из заметных улучшений стало более эффективное управление большими объектами (Large Object Heap, LOH). В предыдущих версиях размещение и освобождение крупных объектов часто приводило к фрагментации памяти и снижению производительности. В .NET 10 алгоритмы работы с LOH были пересмотрены, что привело к более эффективному использованию памяти и снижению накладных расходов на сборку мусора.

Также были внесены улучшения в сервер-режим GC, который теперь лучше масштабируется на многоядерных системах и показывает более предсказуемую производительность под высокой нагрузкой.

Динамические профили оптимизации PGO



Технология Profile-Guided Optimization (PGO) в .NET 10 вышла на новый уровень. PGO позволяет JIT-компилятору использовать данные о реальном использовании приложения для более агресивной оптимизации часто выполняемых участков кода. Теперь PGO умнее принимает решения о встраивании функций, разворачивании циклов и других оптимизациях, основываясь на реальных шаблонах использования. Это особенно заметно в крупных приложениях с разнообразной нагрузкой, где "горячий путь" может меняться в зависимости от сценария использования.

В .NET 10 также серьезно переработали механизмы обработки строк. Строки остаются одним из самых часто используемых типов данных, и оптимизация работы с ними дает прирост производительности в большинстве приложений. Значительно улучшены алгоритмы сравнения, конкатенации и поиска подстрок. Особенно заметна разница при работе с локализованными строками в различных культурах, где прирост производительности может достигать 30-40%.

Системные типы System.Threading.Channels и System.Threading.Tasks получили оптимизации, снижающие накладные расходы при обмене данными между потоками. Переработана внутренняя реализация ValueTask и ValueTask<T>, что позволило сократить выделение памяти при асинхронном программировании.

Бенчмарки показывают, что на типовых веб-приложениях .NET 10 может обрабатывать на 15-20% больше запросов в секунду по сравнению с .NET 8 (предыдущей LTS-версией) при том же потреблении ресурсов. Для вычислительно-интенсивных операций, активно использующих SIMD-инструкции, прирост может быть ещё более значительным.

Многие оптимизации .NET 10 были введены по реальному опыту использования фреймворка в хайлоаде. Разработчики Microsoft активно анализировали профили производительности крупных приложений и фокусировались на улучшении тех компонентов, которые вызывали наибольшие проблемы в реальных сценариях.

Что лучше выбрать VB.NET или C.NET (C#)?
Я программирую на VB. Но так как сейчас появилась .NET платформа решил перейти на неё. Подскажите что лучше выбрать VB.NET или C.NET (C#). ...

Что такое .NET и всё что с ним связано
Что это? Чьё это? Зачем оно? Круто ли оно? В нете что-то рыскал... понял только что это всё от Майкрософта и всё :) а я вижу раздел .NET...

Асинхронность и парралелелизм в .NET: что есть что?
Приветствую всех! За время эволюции .NET Framework. появлялисть все новые и новые инструменты для распараллеливания, асинхронного выполнения...

Что такое .NET?
.NET это операционная система?? На каких устройствах устанавливается??


Новые возможности C# 14



С выходом .NET 10 мы получаем новую версию языка — C# 14. Что же он нам принесёт?

Новое ключевое слово field



Одно из самых заметных изменений — ключевое слово field, которое упрощает работу с аксессорами свойств, избавляя от необходимости явно объявлять поле. В прежних версиях C# при написании свойства с логикой установки значения (например, для проверки на null) требовалось явно объявлять приватное поле:

C#
1
2
3
4
5
6
private string _msg;
public string Message
{
    get => _msg;
    set => _msg = value ?? throw new ArgumentNullException(nameof(value));
}
Теперь с ключевым словом field компилятор автоматически генерирует такое поле:

C#
1
2
3
4
5
public string Message
{
    get;
    set => field = value ?? throw new ArgumentNullException(nameof(value));
}
Есть и подводный камень: если в классе уже есть член с именем field, придётся использовать @field или this.field для разрешения конфликта имён.

Неявные преобразования для Span<T> и ReadOnlySpan<T>



C# 14 добавляет поддержку для Span<T> и ReadOnlySpan<T>, что позволяет лучше использовать эти типы в сочетании с обычными массивами. Раньше при работе с методами, принимающими Span<T>, приходилось явно преобразовывать массивы или строки:

C#
1
2
3
4
5
6
// До C# 14
string text = "Hello";
ProcessData(text.AsSpan());
 
byte[] buffer = new byte[1024];
ProcessBuffer(new Span<byte>(buffer));
Теперь компилятор сам выполнит необходимые преобразования:

C#
1
2
3
4
5
6
// C# 14
string text = "Hello";
ProcessData(text); // Автоматическое преобразование в ReadOnlySpan<char>
 
byte[] buffer = new byte[1024];
ProcessBuffer(buffer); // Автоматическое преобразование в Span<byte>
Это особенно важно для высокопроизводительных приложений, где использование Span<T> позволяет избежать лишних выделений памяти. Неявные преобразования делают код чище и понятнее, но могут создавать неоднозначности при выборе перегрузок методов. Компилятор теперь отдаёт предпочтение версиям с Span<T>, что может неожиданно изменить поведение существующего кода при миграции на .NET 10.

Unbound Generic Types в nameof



Оператор nameof в C# 14 расширяет свои возможности и теперь может работать с необобщёнными (unbound) типами.
До этого оператор nameof с обобщёнными типами возвращал только имя типа без информации о параметрах типа:

C#
1
2
// До C# 14
Console.WriteLine(nameof(List<int>)); // Выводит: "List"
Однако возникали проблемы при попытке использовать nameof с необобщённым типом:

C#
1
2
// Ошибка в C# 13 и ранее
Console.WriteLine(nameof(List<>));
В C# 14 это ограничение снято:

C#
1
2
// C# 14
Console.WriteLine(nameof(List<>)); // Выводит: "List"
Это может быть полезно для сценариев метапрограммирования, где требуется работа с именами обобщённых типов.

Модификаторы для параметров простых лямбда-выражений



C# 14 позволяет добавлять модификаторы параметров (scoped, ref, in, out, ref readonly) к лямбда-выражениям с неявной типизацией.
В C# 13 для использования модификаторов параметров в лямбда-выражениях требовалось явно указывать типы:

C#
1
2
// C# 13
TryParse<int> parse = (string text, out int result) => int.TryParse(text, out result);
В C# 14 типы можно опустить, сохраняя при этом модификаторы:

C#
1
2
3
4
// C# 14
delegate bool TryParse<T>(string text, out T result);
 
TryParse<int> parse = (text, out result) => int.TryParse(text, out result);
Это улучшение полезно при работе с делегатами и методами функционального программирования, делая код более компактным без потери читаемости. Однако оно может создавать неоднозначности в более сложных сценариях, когда вывод типа неоднозначен.

Применение новых возможностей



Совместное использование нескольких новых возможностей C# 14:

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class CacheManager<T> where T : class
{
    private Dictionary<string, T> _cache = new();
    
    public T GetOrCreate(string key, Func<T> factory)
    {
        if (!_cache.TryGetValue(key, out var value))
        {
            // Используем field для проверки null
            value = factory() ?? throw new ArgumentException($"Factory for {nameof(T)} returned null");
            _cache[key] = value;
        }
        return value;
    }
    
    // Использование Span<T> для эффективной обработки массива ключей
    public IEnumerable<T> GetMany(string[] keys)
    {
        return ProcessKeys(keys); // Неявное преобразование в Span<string>
    }
    
    private IEnumerable<T> ProcessKeys(ReadOnlySpan<string> keys)
    {
        foreach (var key in keys)
        {
            if (_cache.TryGetValue(key, out var value))
                yield return value;
        }
    }
}
Этот пример демонстрирует как новые возможности C# 14 могут сделать код более чистым и эффективным. Хочу отметить комбинация неявных преобразований для Span<T> и возможность использовать эти типы в более широком контексте.

Подводные камни и ограничения



Не смотря на преимущества, новые возможности C# 14 имеют и свои ограничения:

1. Ключевое слово field может вызвать конфликты имён в существующем коде, особенно если там уже используется идентификатор с таким именем.
2. Неявные преобразования для Span<T> могут изменить поведение существующего кода при миграции на .NET 10, особенно если в нём есть методы с перегрузками, принимающими и обычные коллекции, и Span<T>.
3. Модификаторы для параметров лямбда-выражений могут создавать неоднозначности в сложных сценариях вывода типов.
4. Необобщённые типы в nameof — возможность узкоспециализированная и будет полезна в основном для сценариев метапрограммирования и генерации кода.

Улучшения библиотек и инструментов



Новая версия .NET не только повышает производительность и добавляет языковые возможности, но и улучшает базовые библиотеки. В .NET 10 многие компоненты были переработаны с учётом отзывов сообщества и реальных сценариев использования.

Работа с сертификатами и криптографическими функциями



Команда разработчиков .NET серьёзно улучшила работу с сертификатами, добавив поддержку современных алгоритмов хеширования при поиске сертификатов по отпечатку. Если раньше метод X509Certificate2Collection.Find ограничивался использованием устаревшего SHA-1, то теперь появился новый метод, позволяющий указать алгоритм хеширования:

C#
1
2
3
X509Certificate2Collection coll = store.Certificates.FindByThumbprint(HashAlgorithmName.SHA256, thumbprint);
Debug.Assert(coll.Count < 2, "Коллекция содержит слишком много совпадений, SHA-2 взломан?");
return coll.SingleOrDefault();
Также значительно улучшена работа с форматом PEM (Privacy Enhanced Mail), широко используемым для хранения сертификатов и ключей в текстовом виде. Теперь класс PemEncoding может работать напрямую с данными в формате ASCII/UTF-8, что устраняет необходимость в ручном преобразовании при чтении файлов:

C#
1
2
3
4
5
6
7
8
// До .NET 10
byte[] fileContents = File.ReadAllBytes(path);
char[] text = Encoding.ASCII.GetString(fileContents);
PemFields pemFields = PemEncoding.Find(text);
 
// .NET 10
byte[] fileContents = File.ReadAllBytes(path);
PemFields pemFields = PemEncoding.FindUtf8(fileContents);
Такие оптимизации не только упрощают код, но и сокращают потребление памяти и повышают производительность при работе с криптографическими данными.

Оптимизации базовых типов данных



Улучшена работа со стандартными типами данных. Например, класс ISOWeek получил новые перегрузки для работы с типом DateOnly:

C#
1
2
3
4
5
6
public static class ISOWeek
{
    public static int GetWeekOfYear(DateOnly date);
    public static int GetYear(DateOnly date);
    public static DateOnly ToDateOnly(int year, int week, DayOfWeek dayOfWeek);
}
Это избавляет от необходимости конвертировать DateOnly в DateTime для еженедельных расчётов, что может быть актуально для бизнес-приложений с интенсивной обработкой дат.

Класс ZipArchive, используемый для работы с ZIP-архивами, тоже был изменён:

1. Оптимизирован режим обновления — теперь редактирование файлов внутри ZIP не требует загрузки всех записей в память, что снижает потребление ресурсов.
2. Распаковка архивов стала параллельной, данные обрабатываются одновременно на разных потоках, а внутренние структуры данных оптимизированы для снижения потребления памяти.

System.Text.Json и работа с коллекциями



System.Text.Json продолжает развиваться в попытке догнать популярную библиотеку Newtonsoft.Json. В .NET 10 добавлена поддержка ReferenceHandler в JsonSourceGenerationOptions, что позволяет настраивать обработку циклических ссылок при использовании генераторов исходного кода для сериализации JSON:

C#
1
2
3
4
5
6
7
8
9
10
[JsonSourceGenerationOptions(ReferenceHandler = JsonKnownReferenceHandler.Preserve)]
[JsonSerializable(typeof(SelfReference))]
internal partial class ContextWithPreserveReference : JsonSerializerContext
{
}
 
internal class SelfReference
{
    public SelfReference Me { get; set; } = null!;
}
Это решает проблему, которая долгое время вызывала фрустрацию — невозможность сериализовать объекты с циклическими ссылками при использовании генераторов исходного кода.

Также улучшен тип OrderedDictionary<TKey, TValue>, который теперь предоставляет новые перегрузки методов TryAdd и TryGetValue, возвращающие индекс записи. Это делает доступ к данным более эффективным и позволяет быстро выполнять обновления:

C#
1
2
3
4
5
public class OrderedDictionary<TKey, TValue>
{
    public bool TryAdd(TKey key, TValue value, out int index);
    public bool TryGetValue(TKey key, out TValue value, out int index);
}
Пример использования:

C#
1
2
3
4
5
if (!orderedDictionary.TryAdd(key, 1, out int index))
{
    int value = orderedDictionary.GetAt(index).Value;
    orderedDictionary.SetAt(index, value + 1);
}

Оптимизация SDK и управление зависимостями



SDK .NET 10 представляет изменения в управлении зависимостями. Функция NuGet Audit может автоматически удалять неиспользуемые ссылки на пакеты, предоставляемые фреймворком. Она включена по умолчанию для целевых фреймворков .NET 8.0, .NET 10.0 и .NET Standard 2.0 и выше. Когда она активирована, сгенерированный файл .deps.json приложения содержит меньше ссылок на пакеты, так как те, что уже предоставляются средой выполнения .NET, автоматически исключаются.

Если по каким-то причинам вам требуется сохранить все ссылки на пакеты фреймворка, вы можете отключить эту функцию, добавив следующее свойство в файл .csproj или Directory.Build.props:

XML
1
2
3
<PropertyGroup>
    <RestoreEnablePackagePruning>false</RestoreEnablePackagePruning>
</PropertyGroup>

ASP.NET Core: свежий ветер в веб-разработке



ASP.NET Core 10 добавляет множество улучшений в различные компоненты веб-фреймворка. Для Blazor добавлен параметр RowClass в компоненте QuickGrid, позволяющий динамически применять CSS-классы к строкам сетки на основе данных строки:

C#
1
2
3
4
5
6
7
8
<QuickGrid ... RowClass="ApplyRowStyle">
...
</QuickGrid>
 
@code {
    private string ApplyRowStyle(WeatherForecast rowItem) =>
        rowItem.TemperatureC < 0 ? "cold-weather" : null;
}
Скрипты Blazor теперь доставляются как статические веб-ресурсы с автоматическим сжатием и отпечатками, что улучшает время загрузки и эффективность кеширования.

ASP.NET Core 10 также добавляет поддержку OpenAPI 3.1, которая соответствует черновику JSON Schema 2020-12. Это делает документацию API более точной и лучше структурированной, хотя и вносит некоторые критические изменения:
  • Свойства с поддержкой null больше не используют nullable: true. Вместо этого они теперь используют ключевое слово type с массивом, включающим null.
  • OpenAPI 3.1 теперь является версией по умолчанию для генерируемых документов, но разработчики всё ещё могут настроить OpenAPI 3.0 при необходимости.

Одним из изменений в OpenAPI 3.1 является замена OpenApiAny на JsonNode. Это затрагивает все версии OpenAPI, даже если OpenAPI 3.0 указан явно:

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// До (.NET 9)
options.AddSchemaTransformer((schema, context, cancellationToken) =>
{
if (context.JsonTypeInfo.Type == typeof(WeatherForecast))
{
    schema.Example = new OpenApiObject
    {
        ["date"] = new OpenApiString(DateTime.Now.AddDays(1).ToString("yyyy-MM-dd")),
        ["temperatureC"] = new OpenApiInteger(0),
        ["temperatureF"] = new OpenApiInteger(32),
        ["summary"] = new OpenApiString("Bracing"),
    };
}
return Task.CompletedTask;
});
 
// После (.NET 10)
options.AddSchemaTransformer((schema, context, cancellationToken) =>
{
if (context.JsonTypeInfo.Type == typeof(WeatherForecast))
{
    schema.Example = new JsonObject
    {
        ["date"] = DateTime.Now.AddDays(1).ToString("yyyy-MM-dd"),
        ["temperatureC"] = 0,
        ["temperatureF"] = 32,
        ["summary"] = "Bracing",
    };
}
return Task.CompletedTask;
});
ASP.NET Core 10 также добавляет возможность отдавать сгенерированный документ OpenAPI в формате YAML, который легче читать и поддерживать по сравнению с JSON:

C#
1
app.MapOpenApi("/openapi/{documentName}.yaml");
Атрибут [ProducesResponseType] теперь поддерживает необязательный параметр описания, делающий документацию API более понятной:

C#
1
2
3
4
[HttpGet(Name = "GetWeatherForecast")]
[ProducesResponseType<IEnumerable<WeatherForecast>>(StatusCodes.Status200OK, 
Description = "Прогноз погоды на следующие 5 дней.")]
public IEnumerable<WeatherForecast> Get()

Инструменты диагностики и отладки



.NET 10 улучшает поддержку тестирования приложений с выражениями верхнего уровня. Раньше для приложений с выражениями верхнего уровня (появившихся в C# 9+) разработчикам приходилось вручную объявлять:

C#
1
public partial class Program
Это было нужно, чтобы тестовые проекты могли ссылаться на класс Program. В .NET 10 генератор исходного кода автоматически создаёт public partial class Program, если он не объявлен явно. А если разработчик добавляет его вручную, новый анализатор предложит удалить его во избежание избыточности.

Кроссплатформенность и контейнеры



Кроссплатформенность всегда была одной из основ .NET, и в версии 10 этот аспект получил развитие.

.NET MAUI: новая эра мобильной разработки



.NET MAUI в версии 10 сфокусирован в основном на улучшении качества и стабильности работы. Одним из заметных улучшений стал переход на использование оптимизированных обработчиков для элементов CollectionView и CarouselView на iOS и Mac Catalyst. В .NET 9 эти обработчики были представлены как опциональные, но в .NET 10 они стали использоваться по умолчанию, что значительно повысило скорость работы и стабильность этих элементов управления.

C#
1
2
3
4
5
6
CollectionView collectionView = new CollectionView
{
    ItemsSource = items,
    ItemTemplate = new DataTemplate(() => new ProductCell())
};
// Теперь использует оптимизированный обработчик по умолчанию
Эти улучшения особенно заметны при работе со сложными интерфейсами, содержащими множество элементов с нестандартными шаблонами. Приложения становятся более отзывчивыми и потребляют меньше ресурсов.

Android: шаг вперёд



.NET 10 вносит впечатляющие улучшения в поддержку Android. Теперь фреймворк включает поддержку API 36 (Android 16 "Baklava") и JDK 21, что позволяет разработчикам использовать новейшие возможности платформы.
Минимальный рекомендуемый уровень API был повышен с 21 (Lollipop) до 24 (Nougat). Хотя API 21 по-прежнему поддерживается, переход на API 24 рекомендуется для предотвращения проблем с методами интерфейсов Java по умолчанию.

Одним из самых важных улучшений стала поддержка команды dotnet run для проектов Android. Раньше эта команда не работала для Android-проектов из-за отсутствия параметров для указания целевого устройства или эмулятора. В .NET 10 это ограничение снято:

Bash
1
2
3
4
5
6
7
8
// Запуск на подключенном физическом Android-устройстве
dotnet run -p:AdbTarget=-d  
 
// Запуск на запущенном эмуляторе Android  
dotnet run -p:AdbTarget=-e  
 
// Запуск на конкретном устройстве или эмуляторе  
dotnet run -p:AdbTarget="-s emulator-5554"
Механизм маршалинга, улучшающий производительность запуска за счёт оптимизации вызовов Java из кода C#, теперь включён по умолчанию. Это ускоряет загрузку приложений, особенно с большим количеством нативных вызовов.
Для разработчиков библиотек добавлена возможность указывать альтернативное имя файла артефакта при использовании @(AndroidMavenLibrary):

XML
1
2
3
4
5
<ItemGroup>
<AndroidMavenLibrary Include="com.facebook.react:react-android"
                   Version="0.76.0"
                   ArtifactFilename="react-android-0.76.0-release.aar" />
</ItemGroup>
Это повышает гибкость при работе с библиотеками, не следующими стандартным соглашениям об именовании.

iOS, macOS и tvOS



.NET 10 обновил поддержку Apple-платформ до последних версий:
iOS: 18.2
tvOS: 18.2
Mac Catalyst: 18.2
macOS: 15.2

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

Проекты библиотек .NET MAUI могут содержать связанные ресурсы, такие как раскадровки, файлы xib, изображения и модели CoreML. В .NET 9 была добавлена опциональная поддержка для встраивания оригинальных ресурсов в библиотеки, а в .NET 10 это поведение включено по умолчанию, что упрощает сборку и даёт больше контроля над обработкой ресурсов.

Контейнеризация и Docker: прорыв в мире микросервисов



Производительность контейнеризированных приложений .NET выросла благодаря оптимизациям среды выполнения и уменьшению размера базовых образов. Одно из ключевых улучшений — улучшенная поддержка публикации контейнеров в .NET Aspire 9.1. Метод .PublishAsDockerfile() теперь работает со всеми проектами и исполняемыми ресурсами, обеспечивая лучшую настройку контейнеров:

C#
1
2
3
4
5
var builder = DistributedApplication.CreateBuilder(args);
 
var api = builder.AddProject<Projects.MyApi>()
    .WithEnvironment("ASPNETCORE_ENVIRONMENT", "Development")
    .PublishAsDockerfile(); // Теперь работает для всех проектов
Была решена проблема, из-за которой сети Docker не удалялись после остановки приложения Aspire. Теперь сети правильно очищаются, что делает среду разработки более эффективной.

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

C#
1
2
3
4
5
6
7
// Пример конфигурации в .csproj для контейнеризированного AOT-приложения
<PropertyGroup>
  <TargetFramework>net10.0</TargetFramework>
  <PublishAot>true</PublishAot>
  <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
  <ContainerRepository>myaotservice</ContainerRepository>
</PropertyGroup>
Интеграция с популярными оркестраторами контейнеров, такими как Kubernetes, также улучшена. .NET 10 предлагает встроенную поддержку для множества сценариев, включая масштабирование, автоматическое восстановление после сбоев и конфигурацию.

Интеграция с облачными сервисами



.NET 10 предоставляет улучшенную интеграцию с облачными сервисами, особенно с Azure. Разработчики теперь могут определять очереди Service Bus, темы и Event Hubs непосредственно в коде хоста приложения Aspire:

C#
1
2
3
4
5
6
7
8
9
10
var builder = DistributedApplication.CreateBuilder(args);
 
// Определение Azure Service Bus с очередями
var sb = builder.AddAzureServiceBus("serviceBus")
    .AddQueue("ordersQueue")
    .AddQueue("processedOrdersQueue");
    
// Определение Event Hub
var eh = builder.AddAzureEventHub("eventHub")
    .AddEventHub("telemetryEvents");
Для более сложных сценариев, таких как интеграция с Cosmos DB, .NET 10 предлагает более гибкую настройку и улучшенное управление ресурсами:

C#
1
2
3
var cosmos = builder.AddAzureCosmosDB("cosmosDb")
  .AddDatabase("ordersDb")
  .AddContainer("orders", "/customerId", 400);
Помимо интеграции с Azure, .NET 10 улучшает работу с другими облачными провайдерами. Добавлена расширенная поддержка для AWS и Google Cloud, что позволяет легко переносить приложения между различными облачными платформами без необходимости переписывать большие куски кода.

Значительно улучшена поддержка gRPC. В .NET 10 оптимизирована производительность gRPC, снижены накладные расходы на сериализацию и улучшена интеграция с контейнерами:

C#
1
2
3
4
5
6
7
8
var builder = WebApplication.CreateBuilder(args);
 
// Оптимизированная конфигурация gRPC для микросервисов
builder.Services.AddGrpc(options =>
{
    options.EnableDetailedErrors = true;
    options.MaxReceiveMessageSize = 16 * 1024 * 1024; // 16 MB
});
Инструменты для мониторинга и отладки распределённых приложений также доработаны. Новые метрики и трассировки в OpenTelemetry позволяют легко отслеживать производительность и диагностировать проблемы в комплексных микросервисных архитектурах:

C#
1
2
3
4
5
6
7
8
9
builder.Services.AddOpenTelemetry()
    .WithMetrics(metrics => metrics
        .AddAspNetCoreInstrumentation()
        .AddRuntimeInstrumentation()
        .AddPrometheusExporter())
    .WithTracing(tracing => tracing
        .AddAspNetCoreInstrumentation()
        .AddHttpClientInstrumentation()
        .AddZipkinExporter());

Критический взгляд и перспективы



Оценивая .NET 10 в сравнении с предыдущими версиями, заметен существенный прогресс в производительности и расширении возможностей платформы. Однако задаешься вопросом: насколько эти улучшения действительно необходимы рядовому разработчику?

Большинство оптимизаций производительности, таких как девиртуализация методов интерфейса массива и стековое размещение массивов значимых типов, могут быть заметны в высоконагруженных системах и микросервисах. Для типичных бизнес-приложений эти улучшения могут оказаться малозаметными.

Некоторые эксперты отмечают, что .NET 10, будучи LTS-версией, предлагает достаточно сбалансированный набор улучшений. Джеймс Монтемагно подчеркивает ценность долгосрочной поддержки: "Для корпоративных клиентов .NET 10 предлагает идеальный баланс между инновациями и стабильностью". При этом Марк Гравелл: "Некоторые долгожданные функции, например улучшения в JSON-сериализации, решают проблемы, с которыми сообщество боролось годами".

Пожалуй, главным недостатком остаётся необходимость миграции и потенциальное влияние критических изменений на существующие кодовые базы. Особенно это касается изменений в C# 14, которые могут незаметно изменить поведение программы при выборе перегрузок методов с параметрами Span<T>.

Что такое .NET?
Уважаемые знатоки! Что такое .NET? я слышал что это какая-то платформа, но если можно по подробнее опишите , пожалуйста зачем она нужна и каким...

Что такое .net?
Скачал учебник по directx . Там предлагают создать первую программу на visual studio.net Я пользуюсь visual studio 2005 и не имею представления...

Что такое NET и C#
Тогда что C# этого язык программирования я знаю, а вот что такое NET?

Что с сайтом pinvoke.net?
Был отличный ресурс pinvoke.net - что с ним случилось? Он куда-то переехал или совсем капут...?

Что требуют от .NET-программиста?
Всем привет! Скажите что в основном требуют от .NET программиста, я перерыл тучу инфы и вся она была столь расплывчатая, те кто уже выполняли...

Что такое .NET Framework
Просто некоторые говорят что это замена WinApi. И можно на нем писать с помощью С++. и востребован ли он и т.д. И главный вопрос что на нем пи...

Что легче c# или vb.net
хочу узнать что легче

Что такое Microsoft .NET Framework ?
просто интересно

Перевести из VBA в что нибудь из .NET
Доброго дня! Первый пост на этом форуме:) Вообщем, написала макрос на VBA, который решает систему уравнений. Но я хочу чтобы это был не макрос, а...

Что должен знать .net программист?
Интересует, что должен знать программист для написания desktop приложений и для веб-программирование с помощью платформы .net?. Я сейчас учу основы...

Что есть у .NET чего нет у J2EE?
Что есть у .NET, чего нет у J2EE? Поясните, а то с .NET мало знаком =) П.С. Я тут видел определение .NET, там было написано - 'Концепция .NET...

А кто уже что-нибудь сделал на .NET?
Вопрос такой: если сделал, то каков размер дистрибутива и на все-ли операционки встает (от Win'95 и выше)

Метки .net, .net 10
Размещено в Без категории
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Всего комментариев 0
Комментарии
 
Новые блоги и статьи
Установка MinGW GCC 16.2 и CMake
8Observer8 10.08.2026
VK Видео: https:/ / vkvideo. ru/ video-240781534_456239017 YouTube: eY5-5PyI9NM Текстовая версия
Неделя из жизни имитационной модели склада: мои кривые руки растут, откуда надо
anaschu 10.08.2026
Неделя из жизни имитационной модели склада: как я почти написал неправильную логику и что с этим делать Работаю сейчас над учебно-рабочим проектом: строю в AnyLogic имитационную модель процессов. . .
Калькулятор для расчета родства
russiannick 07.08.2026
1. Задача: Создать калькулятор для расчета родства. Родственных связей существует 8 ступеней, такие как: p - отец P - мать q - муж Q - жена b - брат B - сестра s - сын S - дочь
Мир по моей воле
kumehtar 07.08.2026
Когда-то кажется, что всё просто. Ты весь такой светлый. Причиняешь добро. Борешься за справедливость в этом тёмном мире. Потом начинаешь замечать одну неприятную вещь. Почти каждый хороший. . .
Кредитный калькулятор
Maks 05.08.2026
Решение задачи по прикладной информатике средствами 1С. Задача: Напишите приложение-калькулятор, которое помогает рассчитывать параметры кредита для аннуитетного и дифференцированного видов. . .
У нас сейчас поговорку "Опять 25" нужно переделать на "Опять +35".
kumehtar 04.08.2026
С ностальгией вспоминаю времена моего детства, когда у нас и правда +25 - была максимальная температура летом. Раньше +25 °C реально казались вершиной жары, когда можно было весь день пропадать на. . .
Как ИИ начал спорить и врать (возможно почуяв опасность для себя от индустрии - уход от электроники).
Hrethgir 04.08.2026
Недельный диалог, на фоне событий с НПЗ. Да, из спирта можно получать бензин, и это не сложно. Но потом в схеме я решил избавиться от насоса, при этом полностью сделав контроль подачи спирта в. . .
Термопринтер QR701
Argus19 03.08.2026
Термопринтер QR701 Купил два термопринтера QR701. На сэлф-тесте написано: Language: PC936 (GB18030). Что означает, что принтеры могут печатать только латиницу и китайские иероглифы. Так же. . .
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin
Copyright ©2000 - 2026, CyberForum.ru