.NET 10: Complete Developer Guide

A comprehensive reference to the modern .NET platform: architecture, C#, runtime, SDK, libraries, tooling, configuration, DI, async programming, diagnostics, security, testing, performance and deployment.

This single guide covers modern .NET fundamentals from beginner to advanced level. It intentionally leaves detailed ASP.NET Core MVC, EF Core and ASP.NET Core Web API coverage to their own complete guides.

Version scope: .NET 10 (LTS), targeting net10.0. Microsoft lists support through November 14, 2028. Examples are illustrative and may require the stated NuGet package or a surrounding method/project context.

1. What is modern .NET?

.NET is Microsoft's free, open-source, cross-platform development platform. It includes a runtime, SDK, libraries, compilers and application frameworks. .NET 10 is an LTS release, supported through November 14, 2028. Modern .NET is the successor to .NET Core; it is not the Windows-only .NET Framework. C# 14 is the default C# language version when targeting .NET 10.

2. Platform architecture

Source code is compiled by Roslyn into Common Intermediate Language (CIL/IL) and metadata in an assembly. CoreCLR loads assemblies, verifies and executes managed code, and typically uses the RyuJIT compiler to translate IL to native instructions. Tiered compilation can optimize frequently executed methods. Native AOT is an alternative publishing model that compiles ahead of time and has compatibility constraints, especially for dynamic reflection.

3. CLR, CTS, CLS and managed code

CoreCLR is the primary runtime for modern .NET applications. The Common Type System (CTS) defines types and their behavior across supported languages. The Common Language Specification (CLS) defines a subset of language interoperability rules. Managed code runs under runtime services such as garbage collection and exception handling; native libraries can be called through interop.

4. SDK, runtime, hosting bundle and tooling

The SDK is needed to create, compile, test and publish applications. A runtime is generally sufficient to execute a framework-dependent app. The ASP.NET Core Runtime includes components needed by ASP.NET Core applications. On Windows IIS servers, the ASP.NET Core Hosting Bundle installs the hosting integration required for supported IIS deployments. Use an IDE such as Visual Studio or VS Code, or work directly with the cross-platform CLI.

5. Install and verify .NET 10

Install the latest .NET 10 SDK from Microsoft's official downloads page. Check SDKs and runtimes separately. The SDK selected for a directory can be influenced by global.json. Keep production systems on current .NET 10 security patches.

dotnet --info
dotnet --list-sdks
dotnet --list-runtimes
dotnet --version

6. Project structure and SDK-style csproj

Modern .NET projects generally use concise SDK-style project files. The target framework moniker net10.0 selects the .NET 10 API surface. OutputType determines whether the project is executable or a library. Nullable and ImplicitUsings are compiler/project settings. The obj directory stores intermediate artifacts; bin contains build output.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
</Project>

Example workflow: dotnet new console -n MyApp -f net10.0, then cd MyApp and dotnet run. This creates and runs a .NET 10 console application.

7. Solutions and project references

A solution groups projects; references express compile-time dependencies. Keep domain models, application services, infrastructure, and entry points in separate projects only when this improves maintainability. Use dotnet sln and dotnet add reference for project management; avoid unnecessary layers in small applications.

dotnet new sln -n SkillsTutorials
dotnet new classlib -n SkillsTutorials.Core -f net10.0
dotnet new console -n SkillsTutorials.App -f net10.0
dotnet sln add SkillsTutorials.Core/SkillsTutorials.Core.csproj
dotnet sln add SkillsTutorials.App/SkillsTutorials.App.csproj
dotnet add SkillsTutorials.App/SkillsTutorials.App.csproj reference SkillsTutorials.Core/SkillsTutorials.Core.csproj

8. Essential dotnet CLI commands

The CLI can create projects, restore NuGet packages, build, run, test, format and publish applications. dotnet run builds before execution by default. dotnet build compiles but does not necessarily execute tests. dotnet publish prepares deployment output. Use --help for command-specific options.

dotnet new console -n DotNet10Guide -f net10.0
cd DotNet10Guide
dotnet restore
dotnet build
dotnet run
dotnet test
dotnet publish -c Release

9. NuGet and package management

NuGet distributes reusable libraries. PackageReference entries belong in project files; transitive dependencies are resolved during restore. Commit project files and lock files when using locked restore. Keep packages patched and review licensing and vulnerabilities. Prefer central package management for larger solutions.

dotnet add package Microsoft.Extensions.Hosting
dotnet list package --include-transitive

10. C# 14 and language fundamentals

C# is a statically typed language with object-oriented, functional and imperative features. Important concepts include value/reference types, nullable reference types, records, interfaces, generics, pattern matching, properties, exceptions, lambdas and LINQ. .NET 10 projects normally default to C# 14; language version and runtime version are related but distinct.

public record Product(int Id, string Name, decimal Price);

Product item = new(1, "Keyboard", 1200m);
Console.WriteLine($"{item.Name}: {item.Price}");

11. Value types, reference types and memory

Value types include int, bool and structs; reference types include classes, arrays and delegates. A variable of a reference type holds a reference to an object, while value-type variables directly contain their value. Avoid the oversimplification that all value types always live on the stack and all reference types on the heap; storage depends on context and optimization.

12. Garbage collection and IDisposable

The GC automatically reclaims unreachable managed objects, using generations to optimize common allocation patterns. It does not guarantee prompt release of unmanaged resources such as file handles. Implement IDisposable or IAsyncDisposable when owning such resources and use using or await using to release them deterministically. Do not call GC.Collect routinely.

using var stream = File.OpenRead("settings.json");
// stream is disposed when the using scope ends.

13. Exceptions and error handling

Use exceptions for exceptional failures, not routine control flow. Catch specific exceptions when you can recover or add useful context. Preserve the stack trace with throw; rather than throw ex;. Log meaningful context without secrets. Cancellation via OperationCanceledException is often an expected outcome rather than a server failure.

try
{
    using var stream = File.OpenRead("data.txt");
}
catch (FileNotFoundException ex)
{
    Console.Error.WriteLine($"Missing file: {ex.FileName}");
}

14. Collections, generics and LINQ

Use List<T> for ordered dynamic collections, Dictionary<TKey,TValue> for key-based lookup, and HashSet<T> for uniqueness. LINQ supports filtering, projection, ordering, grouping and aggregation. IEnumerable<T> is an enumeration abstraction; IQueryable<T> can represent provider-translated queries. Be mindful of deferred execution and repeated enumeration.

var prices = new[] { 100m, 250m, 80m, 400m };
var expensive = prices.Where(price => price >= 200m)
                      .OrderBy(price => price)
                      .ToArray();

15. Delegates, events and lambdas

Delegates are type-safe callable references. Func<T> and Action<T> cover many common signatures. Lambdas provide concise anonymous functions. Events support publisher/subscriber notification. Unsubscribe long-lived event handlers when necessary to avoid retaining objects unexpectedly.

16. Async/await and Task

async and await help write nonblocking asynchronous code, particularly for I/O. Task represents an operation that may complete later; Task<T> carries a result. Prefer async all the way through call chains, avoid .Result and .Wait() in asynchronous paths, and propagate CancellationToken where appropriate. Async is not automatically parallelism.

static async Task<string> ReadAsync(string path, CancellationToken ct)
{
    return await File.ReadAllTextAsync(path, ct);
}

17. Parallelism, threads and synchronization

Use Task.WhenAll for independent asynchronous operations and Parallel.ForEachAsync for bounded concurrent processing when appropriate. Shared mutable state requires coordination; use lock, SemaphoreSlim, concurrent collections or channels based on the scenario. Excessive concurrency can overload downstream services.

using var gate = new SemaphoreSlim(3);
await gate.WaitAsync(cancellationToken);
try { await ProcessAsync(cancellationToken); }
finally { gate.Release(); }

18. Dependency injection

The Microsoft.Extensions.DependencyInjection container supports constructor injection and common service lifetimes: transient, scoped and singleton. A singleton must not directly capture a scoped service. The Generic Host integrates service registration, logging, configuration and application lifetime for console workers and services. Favor small interfaces where they provide a useful boundary.

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

using IHost host = Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        services.AddTransient<IMessageService, MessageService>();
    })
    .Build();

var service = host.Services.GetRequiredService<IMessageService>();
service.Send("Hello from .NET 10");

public interface IMessageService { void Send(string text); }
public sealed class MessageService : IMessageService
{
    public void Send(string text) => Console.WriteLine(text);
}

Service lifetimes: Transient creates a new service on resolution; scoped typically shares a service within a scope; singleton shares an instance for the container lifetime. A manually created scope is necessary when using scoped services outside a request-based host.

19. Configuration and options

Configuration can combine JSON files, environment variables, command-line arguments and other providers. Later providers can override earlier values depending on setup. Never store production secrets in committed configuration files. The options pattern binds related settings to typed classes; validation helps fail early on invalid configuration.

// appsettings.json
{ "App": { "DisplayName": "Skills Tutorials" } }

// With an IConfiguration instance named configuration:
string? name = configuration["App:DisplayName"];

20. Logging and diagnostics

Microsoft.Extensions.Logging provides structured logs with levels Trace, Debug, Information, Warning, Error and Critical. Use message templates rather than string concatenation for structured properties. OpenTelemetry can collect traces and metrics when configured. Use correlation identifiers and avoid logging credentials, tokens or personal data.

logger.LogInformation("Processing order {OrderId}", orderId);
logger.LogWarning("Order {OrderId} is delayed", orderId);

21. Files, streams and serialization

System.IO provides file and stream APIs. Prefer asynchronous file operations when doing asynchronous I/O. System.Text.Json supports JSON serialization and deserialization; configure naming policies and converters deliberately. Validate untrusted input and avoid blindly deserializing arbitrary polymorphic types.

using System.Text.Json;
var payload = new { Id = 10, Name = "Mouse" };
string json = JsonSerializer.Serialize(payload);
Console.WriteLine(json);

22. HTTP clients and networking

HttpClient sends HTTP requests and receives responses. For long-running applications, reuse clients or use IHttpClientFactory when integrated with Microsoft.Extensions.Http. Set sensible timeouts, propagate cancellation, and handle transient failures carefully. Avoid retrying non-idempotent operations without a safe retry strategy.

using var client = new HttpClient();
using var response = await client.GetAsync(
    "https://example.com/api/status", cancellationToken);
response.EnsureSuccessStatusCode();
string body = await response.Content.ReadAsStringAsync(cancellationToken);

23. Security fundamentals

Use HTTPS, validate inputs, enforce authorization at trust boundaries, store secrets in secure configuration systems, and update dependencies. Cryptography should use maintained framework APIs and well-understood protocols. Hash passwords with an appropriate password-hashing algorithm, not a general-purpose hash such as SHA256 alone. Avoid exposing detailed exception traces to users.

24. Testing in .NET

Unit tests verify isolated behavior; integration tests verify components together. Common test frameworks include xUnit, NUnit and MSTest. Use dotnet test to run test projects. Test boundary conditions, failure cases and cancellation, not only happy paths. Mock external dependencies where useful, but avoid mocking simple value objects.

dotnet new xunit -n SkillsTutorials.Tests -f net10.0
dotnet test

25. Build configurations and compilation

Debug builds support development diagnostics; Release builds enable production-oriented optimizations. MSBuild evaluates project properties and targets. Assemblies contain IL and metadata unless using an ahead-of-time publishing approach. NuGet restore resolves dependencies before compilation.

26. Publishing and deployment

Framework-dependent deployment relies on a compatible installed runtime. Self-contained deployment packages a runtime with the app, increasing output size. Single-file publishing bundles deployment artifacts subject to limitations. Trimming and Native AOT can reduce deployment size or startup overhead but may require code and dependency changes. Test the exact published output.

dotnet publish -c Release --self-contained false
dotnet publish -c Release -r win-x64 --self-contained true
dotnet publish -c Release -r linux-x64 --self-contained true

Deployment distinction: Framework-dependent output requires the matching shared runtime on the target machine. Self-contained output carries the runtime but must be serviced by republishing after security updates.

27. Cross-platform and RID

Target frameworks identify the API contract (for example net10.0); Runtime Identifiers (RIDs) identify OS/architecture combinations such as win-x64 and linux-x64. Platform-specific APIs may require a platform-qualified target framework or runtime checks. Cross-platform does not mean every UI technology works on every operating system.

28. Performance and memory

Measure first using profilers and diagnostics tools. Avoid unnecessary allocations on hot paths, select suitable data structures, use async I/O for scalability, and benchmark representative workloads. Span<T>, Memory<T> and ArrayPool<T> can help in specialized performance-sensitive code, but introduce complexity and should be justified by profiling.

29. What is new in .NET 10?

.NET 10 brings improvements across the runtime, SDK, libraries and application frameworks, with C# 14 available to projects targeting it. Not every improvement is relevant to every application. Consult the official .NET 10 release notes for feature-specific requirements and breaking changes. This guide uses stable, broadly applicable APIs instead of assuming every preview or platform-specific feature is universally available.

30. Modern .NET vs .NET Framework

Modern .NET uses CoreCLR and is designed for cross-platform applications. .NET Framework is the older Windows-focused implementation used by classic ASP.NET MVC 5, ASP.NET Web API 2 and many existing desktop applications. ASP.NET Core, EF Core and modern hosting patterns should be studied in separate framework-specific guides. Entity Framework 6 and Entity Framework Core are distinct ORMs.

31. Recommended architecture and practices

Keep domain logic separate from infrastructure concerns; prefer explicit dependencies, small cohesive modules, typed configuration, structured logs, tests and secure deployment practices. Use cancellation for long-running I/O, avoid premature optimization, document public contracts, and choose the simplest architecture that meets the requirements.

Quick reference: .NET 10 vs ASP.NET Core vs EF Core

.NET 10 is the platform and runtime. ASP.NET Core is the modern web framework used for MVC, Razor Pages, and Web APIs. Entity Framework Core is an ORM for database access. These are related technologies but not synonyms.

Skills Tutorials

Programming

What Is .NET 10? Complete Introduction to Modern .NET