День 2322. #ЧтоНовенького
Запись Логов по Требованию с Буферизацией. Начало
Обычно нужны подробные логи, когда что-то идёт не так, но когда всё хорошо, зачем платить за хранение логов, которые никогда не проверяются. Хотя выборка логов (log sampling) помогает сократить их объём, сохраняя только часть, иногда нужен другой подход.

Буферизация логов в .NET 9 временно сохраняет логи в памяти и позволяет позже решить, записывать ли их. Буферизация даёт контекстный контроль над тем, какие логи сохраняются на основе фактических результатов выполнения.

Концепция
Буферизация логов представляет новый шаблон потока:
1. Код генерирует логи обычным образом,
2. Нужные логи сохраняются в памяти, а не пишутся немедленно,
3. Позже, на основе определённых условий, вы решаете:
- Очистить буфер и записать все захваченные логи,
- Дать времени жизни буфера истечь, фактически отбрасывая ненужные логи.
Так, например, вы можете буферизировать подробные логи для транзакции, сохраняя их только в случае сбоя транзакции и отбрасывая в случае её успеха.

Две стратегии буферизации
.NET 9 предоставляет две стратегии буферизации: глобальная и по запросу.

1. Глобальная буферизация
Хранит логи в кольцевых буферах, общих для всего приложения. Это подходит для буферизации логов, связанных с длительными процессами или фоновыми задачами. Для базовых сценариев включите буферизацию:

builder.Logging
 .AddGlobalLogBuffer(LogLevel.Information);

Эта конфигурация буферизует все логи от уровня Information. Для более сложных сценариев определите конкретные правила:

builder.Logging.AddGlobalBuffer(o =>
{
  // Буферизация логов уровня Information, категории "PaymentService"
  o.Rules.Add(
   new LogBufferingFilterRule(
    categoryName: "PaymentService",
    logLevel: LogLevel.Information));

  o.MaxBufferSizeInBytes = 100 * 1024 * 1024;
  o.MaxLogRecordSizeInBytes = 50 * 1024;
  o.AutoFlushDuration = TimeSpan.FromSeconds(30);
});

- MaxBufferSizeInBytes – максимальный размер буфера.
- MaxLogRecordSizeInBytes – максимальный размер отдельных записей лога.
- AutoFlushDuration – как долго буферизация лога будет оставаться отключенной после запуска операции записи (flush). В примере выше буферизация будет оставаться отключенной в течение 30 секунд, что позволит приложению нормально писать все логи.

Запись глобального буфера
Чтобы записать буферизованные логи, внедрите класс GlobalLogBuffer и вызовите его метод Flush():

public class PaymentService
{
  private ILogger<PaymentService> _logger;
  private GlobalLogBuffer _buffer;

  public PaymentService(
   ILogger<PaymentService> logger, 
   GlobalLogBuffer buffer)
  {
    _logger = logger;
    _buffer = buffer;
  }

  public async Task ProcessPayment(
   PaymentRequest req)
  {
    try
    {
      _logger.LogInformation(
       "Старт обработки платежа для транзакции {TransId}", req.TransactionId);
      // Обработка платежа...
      _logger.LogInformation("Платёж обработан");
    }
    catch (Exception ex)
    {
      _logger.LogError(ex, "Сбой обработки");
      // Записываем буфер для записи детальных логов
      _buffer.Flush();
      throw;
    }
  }
}

В этом примере подробные логи о процессе оплаты сохраняются только в случае возникновения исключения.

Окончание следует…

Источник: https://devblogs.microsoft.com/dotnet/emit-logs-on-demand-with-log-buffering/

День 2323. #ЧтоНовенького
Запись Логов по Требованию с Буферизацией. Окончание
Начало

2. Буферизация по запросу
Для веб-приложений ASP.NET Core буферизация по запросу обеспечивает более детальный контроль, поддерживая отдельные буферы для каждого HTTP-запроса. Подходит для отслеживания полного контекста отдельных взаимодействий пользователей.

Добавляем буферизацию по запросу:

builder.Services.AddPerIncomingRequestBuffer(o =>
{
  // Логи Information от API контроллеров
  o.Rules.Add(
   new LogBufferingFilterRule(
    categoryPrefix: "MyApp.Controllers",
    logLevel: LogLevel.Information));

  o.AutoFlushDuration = TimeSpan.FromSeconds(5);
});

Ключевое отличие от глобальной буферизации - когда HTTP-запрос завершается, буфер очищается и все его логи удаляются.

Очистка буфера по запросу
Чтобы выдать буферизованные логи для определённого запроса, внедрите класс PerRequestLogBuffer:

[ApiController]
[Route("[controller]")]
public class OrderController : ControllerBase
{
  private ILogger<OrderController> _logger;
  private PerRequestLogBuffer _buffer;

  public OrderController(
   ILogger<OrderController> logger,
   PerRequestLogBuffer buffer)
  {
    _logger = logger;
    _buffer = buffer;
  }

  [HttpPost]
  public IActionResult CreateOrder(
   OrderRequest request)
  {
    try
    {
      _logger.LogInformation("Заказ для клиента {CustomerId}", request.CustomerId);
      // Обработка заказа…
      _logger.LogInformation("Заказ {OrderId} создан", orderId);

      return Ok(new { OrderId = orderId });
    }
    catch (Exception ex)
    {
      _logger.LogError(ex, "Сбой заказа");
      _buffer.Flush();
      return StatusCode(500, "Сбой создания заказа");
    }
  }
}

Запись (flush) буфера по запросу также записывает глобальный буфер, гарантируя, что все соответствующие логи будут записаны при возникновении ошибки.

Динамические обновления конфигурации
Если вы используете провайдер конфигурации, поддерживающий перезагрузки (например, File Configuration Provider), вы можете обновить правила буферизации без перезапуска приложения.

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

Рекомендации
1. Стратегия буферизации
Буферизуйте подробные логи с уровня Information, но позвольте логам Error и Critical записываться немедленно. Это гарантирует, что важные проблемы всегда будут видны, а подробный контекст будет доступен только при необходимости.

2. Создайте явные триггеры записи (flush)
Определите конкретные условия, при которых контекст лога имеет значение, и добавьте явные вызовы записи:
- При исключениях или ошибках,
- Когда операции превышают ожидаемую продолжительность,
- Когда обнаружено что-то подозрительное.

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

Ограничения
-.NET 9 и выше,
- Точный порядок логов может не сохраняться (временные метки сохраняются),
- Области (scope) логов не поддерживаются,
- Некоторые расширенные свойства записи логов (например, ActivitySpanId) не сохраняются.

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

Источник: https://devblogs.microsoft.com/dotnet/emit-logs-on-demand-with-log-buffering/

День 2327. #ЧтоНовенького
Вам не Хватало Vim в Windows? Представляем Edit!
Edit — это новый текстовый редактор командной строки в Windows. Edit имеет открытый исходный код. Вы можете посмотреть код на GitHub или установить его, выполнив следующую команду:

winget install Microsoft.Edit

Edit будет доступен для предварительного просмотра в программе Windows Insider в ближайшие месяцы. После этого он будет поставляться как часть Windows 11.

Как использовать?
Введите edit в командной строке или edit <your-file-name>, чтобы открыть файл. Теперь вы можете редактировать файлы непосредственно в командной строке без переключения контекста.

Возможности
Edit — это небольшой, легкий текстовый редактор. Он занимает менее 250 КБ. Он пока находится на ранней стадии разработки, но у него есть несколько готовых функций:
1. Поддержка режима мыши
Пункты меню другие элементы UI поддерживают использование мыши, а также горячие клавиши.
2. Открытие нескольких файлов
Вы можете открыть несколько файлов в Edit и переключаться между ними с помощью Ctrl+P (или щелкнув на список файлов в правом нижнем углу).
3. Поиск и замена
Вы можете найти и заменить текст с помощью Ctrl+R или выбрать Edit > Replace в меню. Также есть поддержка регистра и регулярных выражений.
4. Перенос по словам
Edit поддерживает перенос по словам. Чтобы использовать перенос по словам, вы можете использовать Alt+Z или выбрать View > Word Wrap в меню.

Зачем нам ещё один CLI-редактор?
Edit - текстовый редактор CLI по умолчанию в 64-разрядных версиях Windows. 32-разрядные версии Windows поставляются с редактором MS-DOS, но в 64-разрядных версиях редактор CLI не установлен.

В Microsoft решили, что нужен немодальный редактор для Windows (в отличие от модального редактора, в котором новым пользователям пришлось бы запоминать различные режимы работы и как переключаться между ними). К сожалению, это ограничило выбор списком редакторов, которые либо не имели собственной поддержки для Windows, либо были слишком большими, чтобы включать их в каждую версию ОС. В результате родился Edit.

Источник: https://devblogs.microsoft.com/commandline/edit-is-now-open-source/

День 2343. #ЧтоНовенького
Вышел 5 Превью .NET 10. Начало
Microsoft объявили о выпуске .NET 10 превью 5, представив обновления для нескольких компонентов, включая ASP.NET Core, .NET MAUI, WPF и EF Core.

ASP.NET Core
1. Появилась возможность настраивать пользовательские дескрипторы безопасности для очередей запросов HTTP.sys через свойство RequestQueueSecurityDescriptor в HttpSysOptions. Это обеспечивает лучший контроль над доступом к очередям запросов на уровне ОС.

2. API валидации, поддерживающие Minimal API, были помечены как экспериментальные, чтобы разрешить будущие модификации, хотя API AddValidation верхнего уровня остаются стабильными.

3. Генерация OpenAPI была улучшена в версии 3.1. Выпуск также расширяет извлечение метаданных из XML-документации, распознавая теги <returns> и <response> для описаний ответов.

4. В Blazor представлен метод для более простого рендеринга страниц Not Found путем указания компонента NotFoundPage в конфигурации маршрутизатора. Этот подход имеет приоритет над старым фрагментом NotFound. Теперь страница NotFound.razor включена в шаблоны проектов по умолчанию и будет отображаться всякий раз, когда в приложении вызывается метод NavigationManager.NotFound():

<Router AppAssembly="@typeof(Program).Assembly" NotFoundPage="typeof(Pages.NotFound)">
  <Found Context="routeData">
    <RouteView RouteData="@routeData" />
    <FocusOnNavigate RouteData="@routeData" Selector="h1" />
  </Found>
  <NotFound>This content will be ignored because we have NotFoundPage defined.</NotFound>
</Router>

5. Введены подробные метрики и возможности трассировки для приложений Blazor. Метрики публикуются через выделенные счетчики для компонентов, событий жизненного цикла и конвейеров сервера. Трассировка использует новый источник активности Microsoft.AspNetCore.Components, включающий подробный инструментарий для навигации, обработки событий и жизненных циклов конвейера. Разработчики могут включить эту диагностику, настроив OpenTelemetry для сбора данных из соответствующих источников и счётчиков:

builder.Services
 .ConfigureOpenTelemetryMeterProvider(p =>
{
  p.AddMeter("Microsoft.AspNetCore.Components");
  p.AddMeter("Microsoft.AspNetCore.Components.Lifecycle");
  p.AddMeter("Microsoft.AspNetCore.Components.Server.Circuits");
});

builder.Services
 .ConfigureOpenTelemetryTracerProvider(p =>
{
  p.AddSource("Microsoft.AspNetCore.Components");
});

Окончание следует…

Источник: https://www.infoq.com/news/2025/06/dotnet-10-preview-5/

День 2344. #ЧтоНовенького
Вышел 5 Превью .NET 10. Окончание
Начало

MAUI
1. Добавлена поддержка глобальных и неявных пространств имён XAML. Это упрощает разметку, позволяя разработчикам использовать элементы управления без указания нескольких объявлений xmlns. Новое глобальное пространство имён может включать пользовательские представления, конвертеры и сторонние библиотеки, что позволяет сделать XAML более чистым и удобным для обслуживания. Функцию можно активировать через свойства проекта, что снижает необходимость в подробных объявлениях. Однако Microsoft отмечает, что могут возникать ошибки инструментов, пока эта функция остаётся в предварительной версии.

2. Добавлена возможность перехвата веб-запросов в HybridWebView благодаря обработке события WebResourceRequested. Можно изменять или блокировать запросы, позволяя использовать такие сценарии, как внедрение пользовательских заголовков или обслуживание локальных ресурсов:

<HybridWebView WebResourceRequested="HybridWebView_WebResourceRequested" />

WPF
1. Представлен сокращённый синтаксис для Grid.RowDefinitions и Grid.ColumnDefinitions, делая XAML более лаконичным и улучшая поддержку Hot Reload.

2. Улучшения шрифтов и глобализации включают добавление шрифта simsun-extg для улучшения рендеринга на восточноазиатских языках. Тема Fluent была усовершенствована, устраняя сбои и улучшая стили для макетов RTL. Повышение производительности было достигнуто за счёт сокращения выделения памяти и удаления неиспользуемых путей кода.

Entity Framework
В предыдущих версиях EF Core, когда вы указывали значение по умолчанию для свойства, EF Core всегда позволял базе данных автоматически генерировать имя ограничения. Теперь вы можете явно указать имя для ограничений значения по умолчанию для SQL Server, что даёт больше контроля над схемой БД:

protected override void OnModelCreating(ModelBuilder mb)
{
  mb.Entity<Blog>()
   .Property(b => b.IsActive)
   .HasDefaultValue(true, "DF_Blog_IsActive");

  mb.Entity<Post>()
   .Property(p => b.CreatedDate)
   .HasDefaultValueSql("GETDATE()", "DF_Post_CreatedDate");
}

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

protected override void OnModelCreating(ModelBuilder mb)
{
  mb.UseNamedDefaultConstraints();
}

Полный список новинок можно посмотреть здесь

Источник: https://www.infoq.com/news/2025/06/dotnet-10-preview-5/

День 2354. #ЧтоНовенького
ToListAsync в Entity Framework Снова Быстрый
Если вы извлекаете очень большую строку NVARCHAR(MAX) через await ToListAsync(), Entity Framework будет делать что-то непонятное, что приводит к медленному запросу и большому объёму выделения памяти. На самом деле, виновник не совсем Entity Framework. Основную работу выполняет базовый Microsoft.Data.SqlClient. Проблема в том, что он неправильно использует SqlDataReader.

Замечание: это касается в основном пакета/реализации для SqlServer, поскольку он использует пакет Microsoft.Data.SqlClient.

Вот вырезка из бенчмарка от @Wraith2:

| Method | Mean      | Allocated |
|------- |----------:|----------:|
| Async  | 757.51 ms | 101.49 MB |
| Sync   |  39.40 ms |  80.14 MB |

Microsoft.Data.SqlClient 6.1.0
@Wraith2 исправил проблему серией пул-реквестов, на протяжении более 5 лет! Это невероятно. Конечно, он не работал над исправлениями непрерывно 5 лет, но всё равно это очень впечатляет. Последние заметки о выпуске можно прочитать здесь. Обратите внимание на материалы "Added packet multiplexing support to improve large data read performance" (Добавлена поддержка мультиплексирования пакетов для повышения производительности чтения больших объёмов данных).

А пул-реквест, исправляющий проблему, находится здесь.
Результаты такие:

| Async  |  49.45 ms | 101.51 MB |
| Sync   |  40.09 ms |  80.14 MB |

Разрыв в выделении памяти в 20% всё ещё сохраняется, но время уже сопоставимо. Wraith2 и команда проделали потрясающую работу. Вы можете протестировать превью версию пакета, даже используя EF, поскольку прямые зависимости переопределяют транзитивные. Либо подождите следующего релиза EF, включающего новую версию Microsoft.Data.SqlClient 6.1.0, который должен уже скоро выйти.

Источник: https://steven-giesel.com/blogPost/dd7ab934-c311-45e0-9a04-9a28c624b957/tolistasync-is-fast-again-in-entity-framework-kind-of

День 2357. #ЧтоНовенького #NET10
Разбираем Возможности dotnet run app.cs. Начало
В этой серии подробно разберём новую функцию, появившуюся в .NET 10, для сборки и запуска одного C#-файла без необходимости предварительного создания проекта .csproj. Похоже, у неё пока нет окончательного названия. В некоторых источниках её называют однофайловым приложением (file-based app), иногда - «runfile».

Что это?
В .NET 10 добавлена возможность сохранить код в один файл .cs и запустить его, выполнив команду

dotnet run app.cs

См. представление новой функции здесь.

Доступные функции
Пока возможности относительно ограничены, но есть несколько точек расширения. Следующий пример демонстрирует простое хост-приложение Aspire без операций, реализованное в виде однофайлового приложения. Он ничего не делает, а просто демонстрирует все функции, доступные в .NET 10 превью 5:

#!/usr/bin/dotnet run

#:sdk Microsoft.NET.Sdk
#:sdk Aspire.AppHost.Sdk 9.3.0

#:package Aspire.Hosting.AppHost@9.3.0

#:property UserSecretsId 2eec9746-c21a-4933-90af-c22431f35459

using Microsoft.Extensions.Configuration;

var builder = DistributedApplication.CreateBuilder(args);
builder.Configuration.AddInMemoryCollection(new Dictionary<string, string?>
{
  { "ASPIRE_DASHBOARD_OTLP_ENDPOINT_URL", "https://localhost:21049" },
  { "ASPIRE_RESOURCE_SERVICE_ENDPOINT_URL", "https://localhost:22001" },
  { "ASPNETCORE_URLS", "https://localhost:17246" },
});

builder.Build().Run();

Этот скрипт демонстрирует все новые директивы, доступные в режиме запуска однофайлового приложения.

1. Создание исполняемого файла с помощью шебанг
#! (шебанг) и представляет директиву для систем *nix, позволяющую запускать файл напрямую. См. подробнее.

2. Добавление ссылок на SDK
Возможно с помощью директивы #:sdk. Также, как видите, можно указать версию. Заметьте, что в превью 5 она указывается через пробел, но, возможно, синтаксис поменяется для соответствия синтаксису добавления NuGet-пакетов.

3. Добавление ссылок на NuGet-пакеты
Возможно с помощью директивы #:package. Версия указывается после @. Можно использовать подстановочный знак (*) для версий:

#:package Aspire.Hosting.AppHost@*
#:package Aspire.Hosting.AppHost@9.*
#:package Aspire.Hosting.AppHost@9.3.*

Подстановочный знак обычно выберет наивысшую версию пакета.

4. Обновление свойств MSBuild
#:property используется для определения свойств MSBuild для приложения. Можно добавить любые свойства, которые обычно определяются в <PropertyGroup> файла .csproj. Здесь синтаксис, скорее всего тоже изменится. Вместо пробела нужно будет использовать =.

5. Ссылки на проекты (скоро)
В .NET 10 превью 6 должна появиться возможность ссылаться на проекты с помощью директивы #:project

#:project ../src/MyProject
#:project ../src/MyProject/MyProject.csproj

Возможность ссылаться на каталог проекта вместо полного пути к файлу .csproj — отличный способ уменьшить дублирование.

Продолжение следует…

Источник: https://andrewlock.net/exploring-dotnet-10-preview-features-1-exploring-the-dotnet-run-app.cs/

День 2358. #ЧтоНовенького #NET10
Разбираем Возможности dotnet run app.cs. Продолжение
Начало

Зачем?
Прежде всего, команда .NET ясно дала понять, что это делается для того, чтобы сделать обучение новичков .NET максимально удобным. Во многих других языках, будь то Node.js или Python, например, есть однофайловый интерфейс, а теперь он есть и в .NET. Новичок теперь может начать просто с файла .cs, и постепенно вводить новые концепции.

Постепенно вы дойдёте до точки, когда будет иметь смысл создать проект, например, для объединения нескольких CS-файлов. Тогда можно просто преобразовать отдельный файл в проект, выполнив:

dotnet project convert app.cs

Выполнение этой команды на примере из предыдущего поста создаст файл проекта, который выглядит следующим образом:

<Project Sdk="Microsoft.NET.Sdk">
  <Sdk Name="Aspire.AppHost.Sdk" Version="9.3.0" />

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <PropertyGroup>
    <UserSecretsId>2eec9746-c21a-4933-90af-c22431f35459</UserSecretsId>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Aspire.Hosting.AppHost" Version="9.3." />
  </ItemGroup>
</Project>

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

Кроме того, есть несколько сценариев, где избавление от необходимости в отдельном проекте (и соответствующем каталоге) имеет смысл. Например:
1. Сервисные скрипты. Раньше вы, вероятно, использовали бы bash или PowerShell, но теперь, если хотите, можете легко использовать C#.
2. Примеры. Многие библиотеки или фреймворки предлагают несколько примеров приложений для демонстрации функций, каждому из которых требуется отдельная папка и файл проекта. Теперь у вас может быть одна папка, где каждый CS-файл будет примером приложения.

Дополнительные функции
Также существуют различные файлы, которые однофайловое приложение будет неявно использовать, если они доступны. К ним относятся:
- global.json
- NuGet.config
- Directory.Build.props
- Directory.Build.targets
- Directory.Packages.props
- Directory.Build.rsp
- MSBuild.rsp
Пожалуй, самый полезный из этих файлов — Directory.Build.props, который, по сути, позволяет «улучшить» ваше однофайловое приложение, добавив всё, что вы обычно помещаете в файл .csproj. Это особенно полезно, если у вас, например, есть несколько однофайловых приложений в каталоге, и вы хотите задать свойство или добавить пакет для всех, не обновляя каждое из них.

Это всё немного абстрактно, но вы можете увидеть различные примеры подобных вещей в репозитории «runfile Playground» Дэмиана Эдвардса, посвящённом этой функции!

Окончание следует…

Источник: https://andrewlock.net/exploring-dotnet-10-preview-features-1-exploring-the-dotnet-run-app.cs/

День 2359. #ЧтоНовенького #NET10
Разбираем Возможности dotnet run app.cs. Окончание
Начало
Продолжение

Наконец, посмотрим, что ещё готовится для однофайловых приложений.

Нет гарантии, что описанные ниже функции попадут в финальную версию, но есть большие шансы на это, учитывая, что первые несколько функций уже объединены в ветку следующего превью.

1. Публикация однофайловых приложений
Одна из функций, которая должна появиться в превью 6, — это возможность публиковать однофайловые приложения с помощью:

dotnet publish app.cs

При этом по умолчанию приложения будут публиковаться как приложения NativeAOT! Вы можете отключить это, добавив #:property PublishAot false, но, скорее всего, всё будет работать без проблем во многих сценариях, для которых предназначены однофайловые приложения.

2. Запуск через dotnet app.cs
Поддержка запуска однофайловых приложений без использования команды run, т.е. вы можете использовать

dotnet app.cs

вместо

dotnet run app.cs

Одно из главных преимуществ этого подхода заключается в том, что он делает поддержку шебангов в Linux более надёжной. Например, если вы хотите использовать /usr/bin/env для поиска исполняемого файла dotnet, вместо того, чтобы предполагать, что он находится в /usr/bin/dotnet, раньше нужно было сделать что-то вроде этого:

 
#!/usr/bin/env dotnet run

К сожалению, из-за того, что здесь приходится предоставлять несколько аргументов ("dotnet run"), это может не работать в некоторых оболочках. Однако с новой поддержкой dotnet app.cs вы можете использовать более простой и широко поддерживаемый вариант:

#!/usr/bin/env dotnet

3. Запуск C# напрямую из стандартного ввода
Недавно была добавлена поддержка конвейеризации C#-кода напрямую в dotnet run, что позволяет выполнять такие действия:

> 'Console.WriteLine("Hello, World!");' | dotnet run -
Hello, World!

Это перенаправляет приложение Hello World прямо из консоли в dotnet run и запускает его. Классический случай, когда «так делать ни в коем случае нельзя, но люди постоянно это делают», — скачиваем код из сети через curl и запускаем его напрямую - теперь возможен:

> curl -S http://totally-safe-not-scary-at-all.com/ | dotnet run -
All your bases are belong to us!

Чего не будет?
1. Одна из важных функций, которая не появится в .NET 10, — это поддержка нескольких файлов. Изначально планировалось включить её, причём такие вещи, как «вложенные» файлы и подкаталоги, которые неявно включались в компиляцию. Вместо этого эта работа была перенесена на .NET 11, чтобы сосредоточиться на максимальном улучшении взаимодействия с одним файлом.
Вы можете косвенно получить поддержку нескольких файлов, используя Directory.Build.props и Directory.Build.targets, а также добавляя ссылки на файлы «вручную».

2. Поддержка отдельных файлов не появится в Visual Studio. Поддержка от Microsoft будет реализована только в Visual Studio Code (и, разумеется, в CLI).

3. На данном этапе поддержка отдельных файлов будет реализована только для файлов .cs, а не для файлов .vb или .fs. Команда разработчиков не исключает полностью эту возможность, но маловероятно, что Microsoft сами добавят такую поддержку.

Источник: https://andrewlock.net/exploring-dotnet-10-preview-features-1-exploring-the-dotnet-run-app.cs/

День 2371. #ЧтоНовенького #EF10
Именованные Фильтры Запросов в EF 10
Глобальные фильтры запросов EF Core долгое время были удобным способом применения общих условий ко всем запросам к сущности. Они особенно удобны в таких сценариях, как мягкое удаление и мультитенантность, когда требуется, чтобы одно и то же выражение WHERE автоматически добавлялось к каждому запросу.

Однако в предыдущих версиях EF Core было одно существенное ограничение: для каждого типа сущности можно было определить только один фильтр. Если нужно было объединить несколько условий, приходилось либо писать явные выражения &&, либо вручную отключать и повторно применять фильтры в конкретных запросах. Если HasQueryFilter вызывался дважды для одной и той же сущности, второй вызов перезаписывал первый.

modelBuilder.Entity<Order>()
 .HasQueryFilter(o => !o.IsDeleted && o.TenantId == id);

Это работает, но делает невозможным выборочное отключение одного условия. IgnoreQueryFilters() отключает оба, заставляя вручную повторно применять тот фильтр, который вам ещё нужен.

EF 10 представляет альтернативу: именованные фильтры запросов. Она позволяет прикреплять несколько фильтров к одной сущности и ссылаться на них по имени. Затем можно отключать отдельные фильтры при необходимости, а не все фильтры сразу.

Чтобы прикрепить несколько фильтров к сущности, вызовите HasQueryFilter, указав имя для каждого фильтра:

modelBuilder.Entity<Order>()
 .HasQueryFilter("SoftDeletionFilter", 
   o => !o.IsDeleted)
 .HasQueryFilter("TenantFilter", 
   o => o.TenantId == tenantId);

Под капотом EF создаёт отдельные фильтры, идентифицируемые по указанным вами именам. Теперь вы можете отключить только фильтр мягкого удаления, сохранив фильтр клиента:

var allOrders = await context
 .Orders
 .IgnoreQueryFilters(["SoftDeletionFilter"])
 .ToListAsync();

Если вы не укажете параметр, IgnoreQueryFilters() отключит все фильтры для сущности.

Совет: Используйте константы для имён фильтров
Именованные фильтры используют строковые ключи. Использование имён в виде строк в коде приводит к опечаткам и трудно уловимым ошибкам. Чтобы избежать этого, определите константы или перечисления для имён фильтров и используйте их повторно при необходимости:

public static class OrderFilters
{
  public const string SoftDelete = nameof(SoftDelete);
  public const string Tenant = nameof(Tenant);
}

modelBuilder.Entity<Order>()
 .HasQueryFilter(OrderFilters.SoftDelete,
  o => !o.IsDeleted)
 .HasQueryFilter(OrderFilters.Tenant,
  o => o.TenantId == tenantId);
…
// В запросе
var allOrders = await context
 .Orders
 .IgnoreQueryFilters([OrderFilters.SoftDelete])
 .ToListAsync();

Определение имён фильтров в одном месте уменьшает дублирование и повышает удобство поддержки. Другой рекомендуемый подход — обернуть вызов в метод расширения:

public static IQueryable<Order> 
 IncludeSoftDeleted(this IQueryable<Order> query)
   => query.IgnoreQueryFilters([OrderFilters.SoftDelete]);

Это делает ваши намерения явными и централизует логику фильтрации в одном месте.

Итого
Добавление именованных фильтров запросов в EF 10 устраняет одно из давних ограничений функции глобальных фильтров запросов EF. Теперь вы можете:
- Прикреплять несколько фильтров к одной сущности и управлять ими по отдельности;
- Выборочно отключать определённые фильтры в запросе LINQ с помощью IgnoreQueryFilters(["FilterName"]);
- Упрощать распространённые шаблоны, такие как мягкое удаление и мультитенантность, без использования сложной условной логики.
Именованные фильтры запросов могут стать мощным инструментом для поддержания чистоты запросов и инкапсуляции логики предметной области.

Источник: https://www.milanjovanovic.tech/blog/named-query-filters-in-ef-10-multiple-query-filters-per-entity

День 2375. #ЧтоНовенького #NET10
Новинки .NET 10 Превью 6. Начало
Microsoft анонсировали шестую превью версию .NET 10, включающую широкий спектр улучшений для среды выполнения .NET, SDK, библиотек, C#, ASP.NET Core, Blazor и .NET MAUI.

CLI
1. Инструменты .NET теперь можно публиковать с поддержкой нескольких идентификаторов среды выполнения (RID) в одном пакете. Разработчики инструментов могут объединять двоичные файлы для всех поддерживаемых платформ, а .NET CLI выберет нужный вариант при установке или запуске. Это значительно упрощает разработку и распространение кроссплатформенных инструментов.

2. Теперь вы можете использовать команду dotnet tool exec для одноразового запуска инструмента .NET без его глобальной или локальной установки. Это особенно полезно для непрерывной интеграции/разработки (CI/CD) или кратковременного использования. Инструмент будет скачан, если он не установлен локально.

3. Возможности интроспекции CLI были расширены с помощью опции --cli-schema, которая выводит машиночитаемое JSON-представление команд, облегчая автоматизацию и написание скриптов.

ASP.NET Core
Улучшено управление памятью пулов. Kestrel, IIS и HTTP.sys теперь поддерживают автоматическое освобождение неиспользуемой памяти из внутренних пулов при бездействии приложений. Как сообщается, это изменение не требует действий разработчика и призвано эффективно снизить потребление памяти. Метрики для пулов памяти теперь доступны в Microsoft.AspNetCore.MemoryPool, и разработчики могут создавать собственные пулы памяти с помощью нового интерфейса IMemoryPoolFactory.

Blazor
1. Новый компонент LinkPreload обеспечивает расширенный контроль над предварительной загрузкой ресурсов фреймворка, повышая производительность и определение базового URL-адреса.

2. Проекты Blazor WebAssembly теперь могут генерировать выходные данные, совместимые с упаковщиками JavaScript, такими как Webpack, установив WasmBundlerFriendlyBootConfig в значение true, что обеспечивает лучшую интеграцию с современными фронтенд-конвейерами.

3. Поддержка валидации в Blazor расширена и теперь включает вложенные объекты и коллекции в формах. Эта новая возможность реализуется через AddValidation() и атрибут [ValidatableType], при этом следует отметить, что атрибут остаётся экспериментальным.

4. Диагностика Blazor также была улучшена: трассировки теперь отображаются как действия верхнего уровня, что упрощает телеметрию в таких инструментах, как Application Insights.

5. Blazor Server теперь поддерживает сохранение состояния канала, позволяя пользователям возобновлять работу после повторного подключения, даже после отключения на стороне сервера. Разработчики могут управлять поведением канала с помощью новых API Blazor.pause() и Blazor.resume(), что поможет снизить потребление ресурсов сервера в периоды бездействия.

Окончание следует…

Источник: https://www.infoq.com/news/2025/07/dotnet-10-preview-6/

День 2376. #ЧтоНовенького #NET10
Новинки .NET 10 Превью 6. Окончание
Начало

ASP.NET Core Identity
Теперь поддерживает ключи доступа (passkey), что обеспечивает современную, устойчивую к фишингу аутентификацию с использованием стандартов WebAuthn и FIDO2.

Минимальные API
Теперь могут интегрировать ответы на ошибки валидации с помощью IProblemDetailsService, обеспечивая более согласованный и настраиваемый вывод ошибок. API валидации перемещены в новый пакет и пространство имен Microsoft.Extensions.Validation, что расширяет их применение за пределы ASP.NET Core.

MAUI
1. Улучшен элемент управления MediaPicker. Теперь разработчики могут выбирать несколько файлов и сжимать изображения непосредственно через API, используя параметры MaximumWidth и MaximumHeight. Эта функция упрощает обработку медиафайлов в приложениях, облегчая управление и обработку пользовательского контента без дополнительной обработки.

var result = await MediaPicker.PickMultipleAsync(
 new MediaPickerOptions
 {
   MaximumWidth = 1024,
   MaximumHeight = 768
 });

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

webView.WebResourceRequested += (s, e) =>
{
  if (e.Uri.ToString().Contains("api/secure"))
  {
    e.Handled = true;
    e.SetResponse(200, "OK", 
     "application/json", GetCustomStream());
  }
};

3. Что касается повышения производительности и стабильности, эта предварительная версия также включает многочисленные исправления и улучшения элементов управления и поведения макета. CollectionView, CarouselView и SearchBar теперь работают более стабильно на разных платформах, благодаря улучшенным функциям обновления выделения, обновления цветов плейсхолдеров и управления памятью. Утечка памяти в CarouselViewHandler2 на iOS была устранена, что повысило общую стабильность приложения. Элемент управления Switch теперь использует нативный цвет по умолчанию, когда свойство OnColor не задано (это свойство задаёт цвет переключателя при включении), обеспечивая более единообразный пользовательский интерфейс.

Источник: https://www.infoq.com/news/2025/07/dotnet-10-preview-6/

День 2396. #ЧтоНовенького #NET10
Ещё Два Метода-Расширения LINQ в .NET 10
В предварительной версии 6 .NET 10 появились ещё два метода LINQ: InfiniteSequence и Sequence.

1. InfiniteSequence
InfiniteSequence — это простой генератор, позволяющий получить бесконечную последовательность из начальной точки, задавая размер шага:

var steps = 
 Enumerable.InfiniteSequence(0, 5)
  .Take(10)
  .ToList();

foreach (var step in steps)
  Console.WriteLine(step);

В результате будут выведены значения 0, 5, 10, 15, …, 45.
Замечание: будьте осторожны и не вызывайте ToList/Count и подобные функции без Take, иначе вы получите исключение «Недостаточно памяти».

2. Sequence
Это почти то же самое, что InfiniteSequence, с той разницей, что можно определить включительно верхнюю границу:

var steps = 
 Enumerable.Sequence(0, 45, 5)
  .ToList();

foreach (var step in steps)
  Console.WriteLine(step);

Результат будет таким же, как в предыдущем примере.

Источник: https://steven-giesel.com/blogPost/5d88d808-03ac-431a-82fa-756b59b38a7d/two-more-linq-extensions-in-dotnet-10

День 2402. #ЧтоНовенького #NET10
Новинки в .NET 10 Превью 7. ASP.NET Core

1. В промежуточное ПО обработки исключений ASP.NET Core добавлен новый параметр конфигурации для управления диагностическим выводом ExceptionHandlerOptions.SuppressDiagnosticsCallback. Этот метод обратного вызова получает контекст запроса и исключения, позволяя добавить логику, определяющую, должно ли промежуточное ПО записывать логи исключения и другие телеметрические данные.
Это полезно, когда вы знаете, что исключение является временным или уже где-то обрабатывается, и вы не хотите, чтобы логи этого исключения засоряли ваш дашборд.
Кроме того, изменилось поведение промежуточного ПО обработки исключений по умолчанию: диагностические данные для исключений, обрабатываемых IExceptionHandler, больше не записываются. Согласно отзывам пользователей, логирование обработанных исключений на уровне ошибок часто было нежелательным, если IExceptionHandler.TryHandleAsync возвращал true. Вернуть предыдущее поведение можно, добавив следующий код:

app.UseExceptionHandler(new ExceptionHandlerOptions
{
  SuppressDiagnosticsCallback = context => false;
});

2. По умолчанию неаутентифицированные и неавторизованные запросы к известным конечным точкам API, защищенным аутентификацией через cookie, теперь приводят к ответам 401 и 403, а не к перенаправлению на URI входа в систему. Такое перенаправление обычно не имеет смысла для API.
Конечные точки API идентифицируются с помощью нового интерфейса IApiEndpointMetadata, и его реализация была автоматически добавлена для следующих конечные точек:
- в [ApiController];
- в минимальных API, принимающих JSON в теле запроса или выдающих JSON-ответы;
- использующих типы возврата TypedResults;
- в SignalR.
Если вы хотите предотвратить это новое поведение, вы можете переопределить события RedirectToLogin и RedirectToAccessDenied при вызове builder.Services.AddAuthentication().AddCookie(…).

3. Упрощены и расширены API аутентификации по ключу доступа (passkey) в шаблонах веб-приложений Blazor, что упрощает реализацию сценариев входа без пароля. Можно попробовать новый шаблон приложения Blazor с поддержкой ключа доступа:

dotnet new blazor -au Individual

4. ASP.NET Core теперь полностью поддерживает домен верхнего уровня .localhost, что позволяет разработчикам запускать несколько локальных приложений с более чётким разделением доменов. Встроенный веб-сервер Kestrel распознаёт адреса .localhost как локальные (loopback), обеспечивая безопасную и согласованную локальную разработку.

5. MVC, Minimal API и методы HttpRequestJsonExtensions.ReadFromJsonAsync были обновлены для поддержки PipeReader в System.Text.Json, что не требует внесения каких-либо изменений в код приложений.
Для большинства приложений это не должно повлиять на поведение. Однако, если приложение использует кастомный JsonConverter, существует вероятность, что конвертер будет некорректно обрабатывать Utf8JsonReader.HasValueSequence. Это может привести к потере данных и возникновению ошибок, таких как ArgumentOutOfRangeException, при десериализации.
Быстрый способ решения проблемы (особенно если вы не являетесь владельцем используемого кастомного JsonConverter) — установить переключатель AppContext "Microsoft.AspNetCore.UseStreamBasedJsonParsing" в значение true. Это должно быть временным решением, а JsonConverter(ы) следует обновить для поддержки HasValueSequence.

6. Теперь можно использовать атрибуты валидации как для классов, так и для записей, что обеспечивает единообразие генерации кода и поведения валидации. Это повышает гибкость при проектировании моделей с использованием записей в приложениях ASP.NET Core.

Источник: https://www.infoq.com/news/2025/08/dotnet-10-preview-7/

День 2407. #ЧтоНовенького
Самая Мощная Новинка .NET 10
Вам знакомо чувство, когда то, чем вы пользовались годами, всегда казалось… незаконченным? Например, методы-расширения. Они, конечно, крутые, но редко когда по-настоящему нужны. Это костыли, скрывающиеся за маской чистого синтаксиса. C# 14 исправляет это с помощью членов-расширений.

Методы расширения всегда были полусырыми. Какой-то статический метод, замаскированный под что-то более интересное. Ни свойств, ни операторов, никакой логической группировки связанных расширений, кроме неуклюжих статических классов. Они никогда не ощущались как принадлежащие к типу. Члены-расширения - взрослая версия того, чем всегда хотели быть методы расширения.

Пример 1: Переписывание ToObservable
Если вы использовали MVVM с WPF, Xamarin, MAUI и т.д., вы, вероятно, писали это сотню раз:

public static class ObservableExtensions
{
  public static ObservableCollection<T> 
   ToObservable<T>(this IEnumerable<T> source)
    => new ObservableCollection<T>(source);
}

Это работает, но выглядит странно; это не похоже на расширение существующего типа. А вот то же с использованием члена-расширения:

public static class EnumerableExtensions
{
  extension(IEnumerable<T> collection)
  {
    public ObservableCollection<T> ToObservable()
      => new ObservableCollection<T>(collection);
  }
}

Видите разницу? Никакого беспорядка. Никаких странных «статических методов, притворяющихся реальными членами класса». Такое ощущение, что этим поведением владеет IEnumerable<T>.

Синтаксис

public static class NameOfExtensionClass
{
  extension(YourType obj)
  {
    // Методы, свойства, 
    // операторы и вложенные типы
  }
}

Пример 2: Добавляем свойства
Простой способ проверки на пустую коллекцию вместо !col.Any() или col.Count == 0 везде:

public static class CollectionExtensions
{
  extension(ICollection<T> collection)
  {
    public bool IsEmpty => this.Count == 0;
  }
}

Использование:

if (myList.IsEmpty)
{
  // Наконец-то код читается, как надо
}

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

Пример 3: Статические Методы-Расширения
Вы можете добавлять статические члены к типам, которыми вы не владеете:

public static class DateTimeExtensions
{
  extension(DateTime)
  {
    public static DateTime UnixEpoch
     => new DateTime(1970, 1, 1);
  }
}

Как это работает изнутри
- Они не изменяют исходный тип.
- Компилятор и метаданные рассматривают их как «присоединённые» члены.
- Инструменты (например, IntelliSense) отображают их так, как будто они принадлежат типу.
- В основе всё по-прежнему безопасно и независимо, просто умнее.

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

Итого
Члены-расширения наконец-то делают расширения полноценными гражданами. Они позволяют API развиваться естественно. Они уменьшают беспорядок. Они делают код читаемым так, как будто он всегда был разработан таким образом. Это не просто синтаксический сахар, это корректировка курса. Они берут то, что начали методы расширения, и завершают работу. Более чистые API, легко обнаруживаемые функции, меньше служебных классов, скрывающихся в случайных пространствах имён, всё это просто кажется… правильным. Они не заставляют вас переосмысливать, как вы пишете часть кода. Они заставляют вас переосмыслить, как вы в целом проектируете его.

См. также «Используем Расширения C# 14 для Парсинга Enum»

Источник: https://blog.stackademic.com/net-10s-most-powerful-feature-isn-t-what-you-think-7d507dd254dc

День 2418. #ЧтоНовенького
Visual Studio 2026
Вышла Insiders (для предварительной оценки) версия Visual Studio 2026. В этой версии VS ИИ становится неотъемлемой частью рабочего процесса разработчика, улучшена производительность, которая меняет ожидания относительно скорости, а современный дизайн делает рабочую среду более лёгкой и сфокусированной.

Новый канал предварительной оценки (Insiders Channel), представленный Microsoft, призван заменить канал превью (Preview Channel) и позволяет разработчикам получать ранний доступ к новым функциям.

Скачать и попробовать новую VS 2026 можно отсюда, подробные примечания к выпуску тут. Также попробуйте бесплатную версию Copilot, чтобы раскрыть всю мощь ИИ в Visual Studio 2026.

Вот некоторые новинки, которые вы найдёте в новой версии:
1. Интеграция ИИ в разработку
ИИ в Visual Studio 2026 вплетён в повседневный кодинг. Вы заметите это, когда перейдёте к новой кодовой базе: IDE поможет вам понять, что вы видите, предложит типы тестов, которые обычно пишутся в вашем репозитории, и будет поддерживать документацию и комментарии в соответствии с вашим кодом. Вы почувствуете, что «адаптивная вставка» (Shift+Alt+V) станет вашим вариантом вставки кода по умолчанию, потому что редактор адаптирует фрагмент к шаблонам и соглашениям вашего проекта. А когда возникнут вопросы по производительности, вам не придётся гадать — рекомендации основаны на реальных трассировках и проверены бенчмарками.

Аудит кода начинается с чётких, применимых на практике данных о корректности, производительности и безопасности — на вашем компьютере, ещё до того, как вы откроете пул-реквест. Всё это время вы контролируете ситуацию. IDE берёт на себя всю рутинную работу, а за вами остаётся окончательное решение. Результат прост: вы работаете быстрее, а ваш код становится лучше.

2. Производительность
Скорость определяет то, что вы можете создать за день. В VS 2026 операции, которые вы чаще всего запускаете — открытие решений, навигация по коду, сборка и нажатие F5 — стали быстрее. Вы заметите, что первый запуск происходит быстрее, крупные решения — легче, а время между идеей и запуском приложения продолжает сокращаться. Выигрыш заметен на больших кодовых базах и сохраняется как на x64, так и на Arm64, так что мощность вашего компьютера напрямую влияет на скорость разработки.

3. Современный внешний вид
Ясность важна, когда вы работаете в IDE. VS 2026 представляет более чистый и современный дизайн. В результате рабочее пространство ощущается спокойным и продуманным. Вы заметите более четкие линии, улучшенные иконки и оптимальное расположение визуальных элементов. Настройки не перегружены, поэтому настройка IDE в соответствии с вашими предпочтениями выполняется быстро. Управление расширениями упрощено, а множество новых цветовых тем делают вашу среду персонализированной — комфортной для длительных сеансов кодинга и позволяющей сосредоточиться в критические моменты. Этот дизайн учитывает ваше внимание и помогает оставаться сконцентрированным.

Это только начало. В Microsoft обещают ежемесячные обновления с последними улучшениями производительности, дизайна и инновациями в ИИ.

PS
Поскольку это только предварительная версия, она, конечно, не лишена косяков. У меня, например, часто не подгружалась подсветка синтаксиса и навигация по коду в декомпилированных файлах. Нажимаешь, например, F12 на классе Task, и открывается простой текстовый файл. Поэтому использовать VS 2026 в проде пока рано. Но скорость, по сравнению с VS 2022, действительно впечатляет.

Источник: https://devblogs.microsoft.com/visualstudio/visual-studio-2026-insiders-is-here/

День 2434. #ЧтоНовенького
Срок Поддержки STS Релизов Продлён до 24 месяцев
Microsoft объявили о продлении срока поддержки релизов .NET Standard Term Support с 18 до 24 месяцев. Изменение политики, вступающее в силу с .NET 9, поддержка которого продлена до 10 ноября 2026 года, совпадает с датой окончания поддержки .NET 8, версии с долгосрочной поддержкой (Long Term Support, LTS).

Как заявили в Microsoft, компания будет придерживаться установленного ежегодного графика выпуска релизов каждый ноябрь. Чётные релизы продолжат получать статус долгосрочной поддержки на 3 года, в то время как нечётные релизы обозначены как версии со стандартной поддержкой (STS). Ранее релизы STS получали обновления в течение 18 месяцев, и прекращали поддерживаться через 6 месяцев после выпуска следующей версии.

Основной причиной этого изменения названы проблемы управления зависимостями. Для таких релизов, как .NET Aspire, Microsoft.Extensions.AI и C# Dev Kit, иногда требуются обновлённые версии пакетов из более новых ежегодных выпусков. Эта ситуация создавала сложности для компаний, придерживающихся политики «только-LTS», поскольку они могли непреднамеренно включить компоненты STS при установке этих релизов, что потенциально сокращало сроки их поддержки. Т.е., когда организации, использующие LTS-релизы, устанавливали компоненты, требующие более новых версий пакетов, они непреднамеренно переводили части своей среды выполнения из статуса LTS в статус STS. Продлённый период поддержки решает эту проблему, обеспечивая поддержку пакетов из .NET 9 до той же даты, что и компонентов из .NET 8.

Что касается отзывов сообщества разработчиков, они выявили различные точки зрения на объявление. Некоторые отметили, что продлённый период поддержки повышает жизнеспособность релизов STS в производственных средах. Например, это изменение затрудняет обоснование отказа от запуска новых проектов на последней версии, независимо от её статуса STS или LTS.

Другие предложили альтернативные решения. Несколько разработчиков предложили Microsoft рассмотреть возможность продления цикла выпуска до 18 месяцев вместо ежегодного. Как отметил один из комментаторов, зрелость фреймворка снизила влияние новых функций, сделав более длинные циклы выпуска более приемлемыми для команд разработчиков.

Изменение политики особенно выгодно компаниям со строгими требованиями к развертыванию «только-LTS», одновременно способствуя внедрению новых возможностей .NET. Как заявили в Microsoft, организациям, планирующим миграцию с .NET 9 на .NET 10, следует продолжить придерживаться текущего графика обновлений, поскольку новые релизы обеспечивают повышение производительности и дополнительные функции.

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

Изменённая модель поддержки вступила в силу немедленно с релизом .NET 9. Microsoft подтвердили, что сохранят существующее трёхлетнее обязательство по поддержке для всех выпусков с долгосрочной поддержкой.

Источник: https://www.infoq.com/news/2025/09/microsoft-extends-dotnet-sts/

День 2454. #ЧтоНовенького
Вышел .NET 10 Release Candidate 2
Microsoft выпустили .NET 10 Release Candidate 2, финальную предварительную сборку перед релизом. Как сообщает команда .NET, RC 2 поставляется с лицензией на поддержку go-live, что позволяет разворачивать продуктовую версию и одновременно проверять платформу перед её официальным релизом. Сборка поддерживается в Visual Studio 2026 Insiders и Visual Studio Code с помощью C# Dev Kit.

Официальная дата выпуска .NET 10 — 11 ноября 2025 года. Это будет релиз с долгосрочной поддержкой (LTS), обеспечивающий три года исправлений и обновлений. Release Candidate 1 (RC1) был доступен 9 сентября, а RC2 — 14 октября. В Microsoft заявили, что этот релиз в первую очередь ориентирован на валидацию, качество и стабильность, а не на добавление новых функций. Команда сделала акцент на постепенном улучшении качества, чтобы обеспечить плавный переход к GA и совместимость со всеми поддерживаемыми рабочими нагрузками.

1. MAUI
Windows теперь поддерживает разрешения на доступ к микрофону через Permissions.RequestAsync<Permissions.Microphone>(), обеспечивая единую модель разрешений для всех платформ. Android получает поддержку SafeAreaEdges, что улучшает поведение макета при отрисовке от края до края и наложениях клавиатуры.

Также улучшили генерацию исходного кода XAML, предлагающую более быструю отладку генерации представлений и упрощённый механизм настройки через свойство <MauiXamlInflator>SourceGen</MauiXamlInflator>. В Microsoft описали эти обновления как часть продолжающейся работы по повышению производительности и предсказуемости разработки MAUI.

Для Android, в RC 2 представлены привязки API 36.1, разработанные совместно с командой платформы Uno. Проекты могут быть ориентированы на net10.0-android36.1 для доступа к новейшим API платформы, при этом EnablePreviewFeatures по-прежнему временно требуется. В этом выпуске также продолжается экспериментальное внедрение CoreCLR для Android, позволяя разработчикам отключать Mono (UseMonoRuntime=false) и запускать приложения в новой среде выполнения. Хотя эта функция пока не готова к использованию в промышленной среде, по заявлению Microsoft, она представляет собой важный шаг к унификации среды выполнения на разных платформах.

Для разработчиков Apple теперь доступны привязки Xcode 26 для .NET для iOS, macOS, Mac Catalyst и tvOS, что обеспечивает совместимость с новейшими SDK Apple и единообразие между целевыми платформами .NET 9 и .NET 10.

2. Entity Framework Core
Добавлены обновления стабильности и надёжности, такие как улучшенная обработка сложных сопоставлений JSON, уточнённые границы транзакций миграции, поддержка повторных запросов через ExecutionStrategy и новые предупреждения анализатора о небезопасной конкатенации SQL.

3. SDK
Добавлена возможность запускать задачи MSBuild на базе dotnet в Visual Studio и msbuild.exe, устраняя давний разрыв между средами сборки dotnet и .NET Framework. Объявляя задачи с Runtime="NET" и TaskFactory="TaskHostFactory", авторы могут повторно использовать одну и ту же реализацию в CLI и IDE без необходимости настройки на несколько платформ.

Как пояснила команда разработчиков, эта функция знаменует собой первый шаг в более масштабной модернизации MSBuild. В будущих выпусках планируется добавить дополнительные возможности в MSBuild, чтобы упростить написание и использование задач .NET, включая:
- Автоматическое обнаружение и загрузку задач .NET без необходимости указания метаданных среды выполнения или TaskFactory;
- Снижение нагрузки на производительность IPC между движком MSBuild и задачами при выполнении вне процесса;
- Поддержку функции Host Object для задач .NET, выполняемых вне процесса.

.NET 10 RC 2 предназначена для проверки качества релиза, что открывает путь к полноценному релизу в следующем месяце. Разработчикам рекомендуется протестировать приложения с RC 2 и поделиться отзывами в официальном обсуждении на GitHub до релиза .NET 10 — 11 ноября 2025 года.

Источник: https://www.infoq.com/news/2025/10/dotnet-10-rc-2-release/

День 2458. #ЧтоНовенького
Microsoft Исправила Самую Серьёзную Уязвимость в ASP.NET Core
На прошлой неделе Microsoft исправили уязвимость, получившую «самый высокий» уровень серьёзности из-за уязвимости безопасности ASP.NET Core.

Эта ошибка подмены HTTP-запросов (CVE-2025-55315) была обнаружена в веб-сервере Kestrel ASP.NET Core. Она позволяет аутентифицированным злоумышленникам подделывать другой HTTP-запрос для кражи учётных данных других пользователей или обхода средств безопасности на стороне клиента.

«Злоумышленник, успешно воспользовавшийся этой уязвимостью, может просматривать конфиденциальную информацию, такую как учётные данные других пользователей (Конфиденциальность), и вносить изменения в содержимое файлов на целевом сервере (Целостность), а также может вызвать сбой на сервере (Доступность)», — заявили в Microsoft во вторник в информационном бюллетене.

Для устранения этой уязвимости Microsoft выпустили обновления безопасности для Microsoft Visual Studio 2022, ASP.NET Core 2.3, ASP.NET Core 8.0 и ASP.NET Core 9.0, а также для пакета Microsoft.AspNetCore.Server.Kestrel.Core для приложений ASP.NET Core 2.x.

Чтобы защитить свои приложения ASP.NET Core от потенциальных атак, Microsoft рекомендует разработчикам и пользователям принять следующие меры:
- Если вы используете .NET 8 или более позднюю версию, установите обновление .NET из Центра обновления Microsoft, затем перезапустите приложение или перезагрузите компьютер.
- Если вы используете .NET 2.3, обновите ссылку на пакет Microsoft.AspNet.Server.Kestrel.Core до версии 2.3.6, затем перекомпилируйте и повторно разверните приложение.
- Если вы используете автономное/однофайловое приложение, установите обновление .NET, перекомпилируйте и повторно разверните.

Как пояснил руководитель технической программы безопасности .NET Барри Дорранс, последствия атак CVE-2025-55315 будут зависеть от целевого приложения ASP.NET, и успешная эксплуатация уязвимости может позволить злоумышленникам войти в систему под другим пользователем (для повышения привилегий), выполнить внутренний запрос (при атаках с подделкой запросов на стороне сервера), обойти проверки на подделку межсайтовых запросов (CSRF) или выполнить атаки с использованием инъекций.

«Мы не знаем, что из этого возможно, потому что всё зависит от того, как вы написали своё приложение. Поэтому мы оцениваем уровень риска, имея в виду наихудший возможный случай — обход функции безопасности, который позволяет изменить привилегии, — сказал Дорранс. — Вероятно ли это? Скорее всего, нет, если только код вашего приложения не делает что-то странное и не пропускает ряд проверок, которые он должен выполнять при каждом запросе. Тем не менее, пожалуйста, обновитесь».

Источник: https://www.bleepingcomputer.com/news/microsoft/microsoft-fixes-highest-severity-aspnet-core-flaw-ever/