.NET | The .NET Blog

.NET 10 wordt Geleverd met Ubuntu 26.04 LTS — Dit Is Nieuw

Emiliano Montesdeoca — Sat, 25 Apr 2026 00:00:00 +0000

Dit bericht is automatisch vertaald. Klik hier voor de originele versie.

Het is Ubuntu LTS-dag. Ubuntu 26.04 (Resolute Raccoon) is vandaag uitgebracht met .NET 10.

.NET 10 in twee commando’s installeren

sudo apt update
sudo apt install dotnet-sdk-10.0

.NET is een van de officieel ondersteunde toolchains op Ubuntu.

Containers: `-noble` bijwerken naar `-resolute`

sed -i "s/noble/resolute/g" Dockerfile

Native AOT: 3ms opstart, 1,4MB binair bestand

apt install -y dotnet-sdk-aot-10.0 clang
dotnet publish app.cs
# native binair bestand van 1,4MB, opstart in 3ms

Voor cloud-native workloads waarbij koude starttijd belangrijk is — Functions, containers, serverless — een echte gamechanger.

.NET 8 of 9 nodig?

apt install -y software-properties-common
add-apt-repository ppa:dotnet/backports
apt install -y dotnet-sdk-8.0

Het volledige bericht bevat meer details.

Native Node.js-addons schrijven in C# met .NET Native AOT

Emiliano Montesdeoca — Tue, 21 Apr 2026 00:00:00 +0000

Dit artikel is automatisch vertaald. Voor de originele Engelse versie, klik hier.

Hier is een scenario dat ik geweldig vind: een team dat werkt aan .NET-tooling had native Node.js-addons geschreven in C++ en gecompileerd via node-gyp. Het werkte. Maar het vereiste Python op elke machine van een ontwikkelaar — een oude versie van Python, let wel — alleen om een pakket te compileren dat niemand in het team ooit rechtstreeks zou aanraken.

Dus stelden ze een heel redelijke vraag: we hebben de .NET SDK al geïnstalleerd, waarom schrijven we überhaupt C++?

Het antwoord was Native AOT, en het resultaat is oprecht elegant. Drew Noakes van het C# Dev Kit-team schreef op hoe ze het aanpakten.

Het basisidee

Een native Node.js-addon is een gedeelde bibliotheek (.dll op Windows, .so op Linux, .dylib op macOS) die Node.js tijdens runtime kan laden. De interface heet N-API — een stabiele, ABI-compatibele C API. N-API maakt niet uit welke taal de bibliotheek heeft geproduceerd, alleen dat die de juiste symbolen exporteert.

.NET Native AOT kan precies dat produceren. Het compileert je C#-code ahead-of-time naar een native gedeelde bibliotheek met willekeurige invoerpunten.

De projectconfiguratie

Het projectbestand is minimaal:

<Project Sdk="Microsoft.NET.Sdk">
 <PropertyGroup>
 <TargetFramework>net10.0</TargetFramework>
 <PublishAot>true</PublishAot>
 <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
 </PropertyGroup>
</Project>

PublishAot vertelt de SDK om een gedeelde bibliotheek te produceren bij dotnet publish.

Het invoerpunt exporteren

Node.js verwacht dat jouw bibliotheek napi_register_module_v1 exporteert. In C# doet [UnmanagedCallersOnly] precies dat:

[UnmanagedCallersOnly(
 EntryPoint = "napi_register_module_v1",
 CallConvs = [typeof(CallConvCdecl)])]
public static nint Init(nint env, nint exports)
{
 Initialize();
 RegisterFunction(env, exports, "readStringValue"u8, &ReadStringValue);
 return exports;
}

Het u8-achtervoegsel produceert een ReadOnlySpan<byte> met een UTF-8 string-literal, rechtstreeks doorgegeven aan N-API zonder enige coderingstoewijzing.

N-API oplossen tegen het hostproces

N-API-functies worden geëxporteerd door node.exe zelf, niet door een aparte bibliotheek. Dus in plaats van ergens tegen te linken, los je ze op tegen het actieve proces bij opstarten:

NativeLibrary.SetDllImportResolver(
 System.Reflection.Assembly.GetExecutingAssembly(),
 ResolveDllImport);

Daarmee werken P/Invoke-declaraties netjes:

[LibraryImport("node", EntryPoint = "napi_create_string_utf8")]
internal static partial Status CreateStringUtf8(
 nint env, ReadOnlySpan<byte> str, nuint length, out nint result);

Aanroepen vanuit TypeScript

dotnet publish produceert jouw platformspecifieke native bibliotheek. Hernoem het naar .node en gebruik het met een standaard require():

const registry = require('./native/win32-x64/RegistryAddon.node') as RegistryAddon;
const sdkPath = registry.readStringValue(
 'SOFTWARE\\dotnet\\Setup\\InstalledVersions\\x64\\sdk',
 'InstallLocation'
);

Dat is het. TypeScript naar C#, geen Python, geen C++.

Samenvatting

Het C# Dev Kit-team verving de overhead van Python/C++ door schone C#-code die iedereen in het team al weet hoe te schrijven en debuggen. Het patroon is niet ingewikkeld zodra je het ziet, en het is een geweldig voorbeeld van Native AOT die een echt probleem oplost dat niet genoeg wordt besproken.

Lees de originele blogpost op het .NET-blog.

Agent Skills in .NET Zijn Nu Serieus Flexibel

Emiliano Montesdeoca — Tue, 14 Apr 2026 00:00:00 +0000

Dit bericht is automatisch vertaald. Voor het origineel, klik hier.

Als je agents bouwt met Microsoft Agent Framework, ken je de werkwijze: je definieert skills, koppelt ze aan een provider en laat de agent bepalen welke hij aanroept. Nieuw is hoe je die skills schrijft — en de sprong in flexibiliteit is aanzienlijk.

De nieuwste update introduceert drie verschillende patronen voor het schrijven van agent skills: bestand-gebaseerd, klasse-gebaseerd en inline code-gedefinieerd. Alle drie koppelen aan één AgentSkillsProviderBuilder, wat betekent dat je ze kunt mixen zonder routeringslogica.

Bestand-gebaseerde skills: het startpunt

Bestand-gebaseerde skills zijn precies wat ze klinken — een map op schijf met een SKILL.md-bestand, optionele scripts en referentiedocumenten:

skills/
└── onboarding-guide/
├── SKILL.md
├── scripts/
│ └── check-provisioning.py
└── references/
└── onboarding-checklist.md

De frontmatter van SKILL.md declareert de skillnaam en beschrijving, en de instructiesectie vertelt de agent hoe scripts en referenties te gebruiken.

Je koppelt het met SubprocessScriptRunner.RunAsync:

var skillsProvider = new AgentSkillsProvider(
 Path.Combine(AppContext.BaseDirectory, "skills"),
 SubprocessScriptRunner.RunAsync);

Klasse-gebaseerde skills: leveren via NuGet

Hier wordt het interessant voor teams. Klasse-gebaseerde skills leiden af van AgentClassSkill<T> en gebruiken attributen zoals [AgentSkillResource] en [AgentSkillScript]:

public sealed class BenefitsEnrollmentSkill : AgentClassSkill<BenefitsEnrollmentSkill>
{
 public override AgentSkillFrontmatter Frontmatter { get; } = new(
 "benefits-enrollment",
 "Enroll an employee in health, dental, or vision plans.");

 [AgentSkillScript("enroll")]
 private static string Enroll(string employeeId, string planCode)
 {
 bool success = HrClient.EnrollInPlan(employeeId, planCode);
 return JsonSerializer.Serialize(new { success, employeeId, planCode });
 }
}

Een team kan dit als NuGet-pakket verpakken. Voeg het toe aan je project, stop het in de builder en het werkt naast je bestand-gebaseerde skills.

Inline skills: de snelle brug

Dat moment wanneer een ander team precies de skill bouwt die je nodig hebt, maar deze pas over een sprint beschikbaar is? AgentInlineSkill is je brug:

var timeOffSkill = new AgentInlineSkill(
 name: "time-off-balance",
 description: "Calculate remaining vacation and sick days.",
 instructions: "1. Vraag om medewerker-ID. 2. Gebruik calculate-balance. 3. Presenteer resultaten.")
 .AddScript("calculate-balance", (string employeeId, string leaveType) =>
 {
 int remaining = HrDatabase.GetAnnualAllowance(employeeId, leaveType)
 - HrDatabase.GetDaysUsed(employeeId, leaveType);
 return JsonSerializer.Serialize(new { employeeId, leaveType, remaining });
 });

Wanneer het NuGet-pakket verschijnt, vervang je de inline skill door de klasse-gebaseerde. De agent merkt het verschil niet.

Scriptgoedkeuring: human-in-the-loop

Voor .NET-ontwikkelaars die productie-agents bouwen, is dit het deel dat implementatiegesprekken daadwerkelijk deblokkert. Zet UseScriptApproval aan en de agent pauzeert voor het uitvoeren van elk script:

var skillsProvider = new AgentSkillsProviderBuilder()
 .UseFileSkill(Path.Combine(AppContext.BaseDirectory, "skills"))
 .UseSkill(new BenefitsEnrollmentSkill())
 .UseSkill(timeOffSkill)
 .UseFileScriptRunner(SubprocessScriptRunner.RunAsync)
 .UseScriptApproval(true)
 .Build();

Samenvatting

Agent skills in .NET hebben nu een echt flexibel schrijfmodel. Of je nu een prototype bouwt met bestand-gebaseerde skills of verpakte mogelijkheden via NuGet levert — alle patronen stellen samen via AgentSkillsProviderBuilder.

Bekijk de originele aankondiging en GitHub-voorbeelden.

.NET | The .NET Blog

.NET 10 wordt Geleverd met Ubuntu 26.04 LTS — Dit Is Nieuw

.NET 10 in twee commando’s installeren

Containers: -noble bijwerken naar -resolute

Native AOT: 3ms opstart, 1,4MB binair bestand

.NET 8 of 9 nodig?

Native Node.js-addons schrijven in C# met .NET Native AOT

Het basisidee

De projectconfiguratie

Het invoerpunt exporteren

N-API oplossen tegen het hostproces

Aanroepen vanuit TypeScript

Samenvatting

Agent Skills in .NET Zijn Nu Serieus Flexibel

Bestand-gebaseerde skills: het startpunt

Klasse-gebaseerde skills: leveren via NuGet

Inline skills: de snelle brug

Scriptgoedkeuring: human-in-the-loop

Samenvatting

Containers: `-noble` bijwerken naar `-resolute`