DotNet AI Hub

.NET & AI Technologies

In-depth guides to .NET, C#, ASP.NET Core, cloud-native development and AI engineering with Microsoft.Extensions.AI, Agent Framework, Semantic Kernel and ML.NET.

100 guides in 11 categories

Welcome to the technology library: long-form, practical guides that explain how modern .NET works and how to build intelligent applications with it. Every guide is written for working developers. It starts with the concepts, moves quickly to real C# code, and finishes with best practices, common pitfalls, comparisons and a short FAQ.

The library is organized into focused categories so you can study one area end to end or jump straight to the topic you need today. Start with AI & Machine Learning in .NET if you are adding large language models, retrieval-augmented generation (RAG) or agents to your applications. Choose .NET Platform & Runtime and C# Language to strengthen your fundamentals. Explore ASP.NET Core, Data Access and Cloud-Native when you are building and shipping services, and use Architecture, Performance and Security to design systems that last.

Guides target current long-term-support releases and call out version-specific behavior where it matters. Each page links to related guides, interview questions and official documentation so you can keep going deeper.

Browse by category

AI & Machine Learning in .NET20 guidesBuild intelligent .NET apps: Microsoft.Extensions.AI, Microsoft Agent Framework, Semantic Kernel, RAG, vector search, MCP, ML.NET, ONNX Runtime and Azure AI Foundry..NET Platform & Runtime9 guidesUnderstand how .NET works under the hood: the CLR, garbage collection, JIT and tiered compilation, Native AOT, dependency injection, the generic host and release cadence.C# Language10 guidesMaster modern C#: C# 14 features, async/await internals, LINQ, generics and variance, records, pattern matching, nullable reference types, source generators and Span<T>.ASP.NET Core & Web11 guidesBuild fast, secure web apps and APIs with ASP.NET Core: Minimal APIs, REST design, middleware, Blazor, SignalR, gRPC, OpenAPI, caching, rate limiting and YARP.Data Access & EF Core8 guidesWork with data in .NET: Entity Framework Core, performance tuning, Dapper, migrations, SQL Server, PostgreSQL, Cosmos DB, MongoDB and caching strategies.Cloud-Native, Azure & Aspire9 guidesShip .NET to the cloud: .NET Aspire, Docker, Kubernetes, Azure Functions, App Service, Container Apps, Dapr, Orleans, OpenTelemetry and resilience with Polly.Architecture & Design Patterns9 guidesDesign maintainable .NET systems: Clean Architecture, DDD, CQRS, event sourcing, microservices, messaging, modular monoliths, design patterns and legacy modernization.Performance & Diagnostics6 guidesMake .NET fast and find problems quickly: high-performance techniques, BenchmarkDotNet, diagnostics tools, memory-leak hunting, parallel programming and System.Text.Json.Security & Identity6 guidesSecure .NET applications: ASP.NET Core authentication and authorization, identity platforms, OWASP Top 10, secrets management, cryptography and data protection.Desktop, Mobile & Cross-Platform UI6 guidesBuild client apps with .NET: .NET MAUI, WPF, WinUI 3, Windows Forms, Blazor Hybrid, and a comparison of MAUI, Avalonia, Uno Platform and Blazor.Testing, Tooling & DevOps6 guidesShip with confidence: unit and integration testing, Testcontainers, CI/CD with GitHub Actions, MSBuild, NuGet packaging and code-quality analyzers for .NET.

All pages

AI & Machine Learning in .NET 20

  1. AI in .NET: The Complete Landscape for DevelopersMap the 2026 AI in .NET ecosystem: Microsoft.Extensions.AI, Agent Framework, Semantic Kernel, vector data, MCP, ML.NET, ONNX and Foundry, and when to use each.
  2. Microsoft.Extensions.AI: Unified AI Abstractions for .NETMaster Microsoft.Extensions.AI: IChatClient, IEmbeddingGenerator, streaming, tool calling, middleware pipelines, DI registration, custom clients and testing.
  3. Microsoft Agent Framework: Build AI Agents in C#Build AI agents in C# with Microsoft Agent Framework 1.x: ChatClientAgent, sessions, tools, MCP, workflows, human approval, hosting and migration.
  4. Semantic Kernel in Practice: Plugins, Functions and OrchestrationSemantic Kernel in practice for C#: kernel, plugins, prompt templates, automatic function calling, filters, vector search, agents, and its 2026 role.
  5. Azure OpenAI and Microsoft Foundry for .NET DevelopersUse Azure OpenAI in Microsoft Foundry (formerly Azure AI Foundry) from .NET: deployments, keyless auth, guardrails, quotas, PTUs, Agent Service and cost.
  6. Using the Official OpenAI .NET Library for C#A practical guide to the OpenAI .NET SDK: ChatClient, streaming, tool calls, structured outputs, the Responses API, embeddings, images, audio and retries.
  7. Retrieval-Augmented Generation (RAG) in .NET: End-to-End GuideBuild production RAG in C#, covering ingestion, chunking, embeddings, hybrid retrieval, reranking, grounded prompts, citations and evaluation in .NET.
  8. Embeddings and Vector Databases in .NET: A Practical GuideLearn how embeddings and vector databases work in .NET: similarity metrics, HNSW indexes, Microsoft.Extensions.VectorData and pgvector, SQL Server and Qdrant.
  9. Function Calling and Tool Use with LLMs in C#Master function calling in C# with Microsoft.Extensions.AI: AIFunctionFactory, FunctionInvokingChatClient, parallel calls, approvals, security and tests.
  10. Model Context Protocol (MCP) in C#: Build Servers and ClientsBuild Model Context Protocol servers and clients in C# with the official SDK 2.x: tools, resources, Streamable HTTP, OAuth, security and VS Code setup.
  11. ML.NET: Practical Machine Learning for .NET DevelopersLearn ML.NET in C#: MLContext, IDataView, pipelines, trainers, AutoML, metrics, PredictionEnginePool, ONNX, and when to pick ML.NET over LLMs.
  12. Local AI in .NET: ONNX Runtime, Ollama and Foundry LocalRun LLMs locally in .NET with ONNX Runtime GenAI, Ollama and Foundry Local: small language models, GPUs and NPUs, quantization and IChatClient.
  13. Multimodal AI in .NET: Vision, Audio and SpeechBuild multimodal .NET apps that understand images, documents, speech and audio, and generate images and voice, with Microsoft.Extensions.AI and Azure AI.
  14. Prompt Engineering for .NET DevelopersA practical guide to prompt engineering for .NET developers, covering prompt anatomy, few-shot examples, reasoning models, templates and injection risks.
  15. Structured Outputs: Reliable JSON from LLMs in C#Get reliable JSON from LLMs in C#: JSON mode vs structured outputs, typed Microsoft.Extensions.AI responses, JSON Schema from types, validation and retries.
  16. Evaluating AI Applications in .NET: Quality, Safety and CIEvaluate LLM apps in .NET with Microsoft.Extensions.AI.Evaluation: quality and safety evaluators, golden datasets, LLM-as-judge, caching, reports and CI gates.
  17. AI Agent Architecture Patterns for .NET: Orchestration, Memory and A2ADesign AI agents in .NET: single vs multi-agent, sequential, concurrent, handoff, group chat and Magentic orchestration, memory, approvals, durability and A2A.
  18. Responsible AI and LLM Security for .NET ApplicationsSecure LLM apps in .NET: OWASP Top 10 for LLMs 2026, prompt injection defenses, Prompt Shields, PII redaction, output checks, least privilege and the EU AI Act.
  19. Observability and Cost Control for LLM Apps in .NETLearn observability and cost control for .NET LLM apps, covering OpenTelemetry GenAI conventions, token tracking, caching, model routing and 429 retries.
  20. AI-Assisted .NET Development with GitHub Copilot and Coding AgentsHow .NET teams use GitHub Copilot, coding agents, custom instructions and MCP servers, plus review, security and modernization guidance for 2026.

.NET Platform & Runtime 9

  1. What's New in .NET 10 (LTS): Runtime, Libraries and SDKA practical tour of .NET 10 LTS: JIT de-abstraction, stack allocation, post-quantum crypto, strict JSON, file-based apps, C# 14 and the .NET 11 outlook.
  2. Inside the CLR: How .NET Loads, Compiles and Executes Your CodeA deep dive into CLR internals: IL and metadata, the type loader, MethodTables, precode and JIT, interface dispatch, object layout, AssemblyLoadContext and SOS.
  3. Garbage Collection in .NET: Generations, Modes and TuningHow the .NET garbage collector works: generations, LOH and POH, regions, workstation vs server GC, DATAS, container limits, finalization and tuning.
  4. JIT Compilation, Tiered Compilation and Dynamic PGO in .NETHow RyuJIT, tier 0/tier 1 compilation, On-Stack Replacement and Dynamic PGO trade startup time for throughput, and how to inspect and tune them.
  5. Native AOT and Trimming in .NET: A Practical GuideA practical guide to Native AOT in .NET, PublishAot, trim warnings, AOT-friendly source generators for JSON, config and logging, and ASP.NET Core support.
  6. .NET Release Cadence, LTS vs STS and Upgrade StrategyHow the .NET release cadence works: LTS vs STS support (STS is now 24 months), end-of-support dates for .NET 8 to 11 and a practical upgrade strategy.
  7. Dependency Injection in .NET: The Complete GuideMaster dependency injection in .NET: service lifetimes, scope validation, captive dependencies, keyed services, open generics, decorators and anti-patterns.
  8. .NET Generic Host: Configuration, Options and LoggingA practical guide to the .NET Generic Host: configuration providers and precedence, validated strongly typed options, and structured high-performance logging.
  9. Background Services and Worker Processes in .NETBuild reliable .NET background services: BackgroundService vs IHostedService, graceful shutdown, PeriodicTimer, Channels queues, Windows Services and systemd.

C# Language 10

  1. C# 14 New Features Explained with ExamplesC# 14 new features explained with examples: extension members, the field keyword, null-conditional assignment, first-class spans and more in .NET 10.
  2. The Evolution of C#: From 1.0 to 14The evolution of C# from 1.0 to 14: a version timeline with .NET and Visual Studio releases, the big themes, LangVersion rules and lessons for modern code.
  3. Async/Await in C#: A Deep DiveAsync/await in C# explained in depth: the compiler state machine, SynchronizationContext, ConfigureAwait, ValueTask, async streams, cancellation and deadlocks.
  4. LINQ in Depth: Deferred Execution, Performance and Best PracticesLINQ in depth for C# developers: deferred execution, IEnumerable vs IQueryable, new operators from .NET 6 to 10, hot-path performance and custom operators.
  5. C# Generics: Constraints, Variance and Generic MathC# generics in depth: constraints up to allows ref struct, covariance and contravariance, how the CLR implements generics, and generic math with INumber.
  6. Records and Pattern Matching in Modern C#: A Practical GuideLearn C# records and pattern matching: record class vs record struct, value equality, with-expressions, list patterns, switch expressions and domain modeling.
  7. Nullable Reference Types in C#: A Practical GuideMaster C# nullable reference types: flow analysis, annotations, the ! operator, nullable attributes, generics and migrating large codebases incrementally.
  8. Delegates, Events, Lambdas and Expression Trees in C#Understand C# delegates, Func and Action, multicast delegates, events, closures, static lambdas, expression trees and how EF Core turns LINQ lambdas into SQL.
  9. Roslyn Source Generators and Analyzers in .NET: A Practical GuideBuild incremental Roslyn source generators and analyzers in .NET: ForAttributeWithMetadataName, caching, code fixes, testing, NuGet packaging and interceptors.
  10. Span<T>, Memory<T> and Ref Structs in .NET ExplainedLearn Span, ReadOnlySpan, Memory and ref structs in .NET: zero-copy slicing, stackalloc, ArrayPool, SearchValues, async buffers and C# 14 span conversions.

ASP.NET Core & Web 11

  1. ASP.NET Core Architecture: Hosting, Kestrel and the Request PipelineLearn how ASP.NET Core architecture works: WebApplication hosting, Kestrel, IIS and reverse proxies, HTTP/3, endpoint routing, middleware and configuration.
  2. Minimal APIs in ASP.NET Core: The Complete GuideBuild fast HTTP APIs with Minimal APIs in ASP.NET Core: route handlers, binding, TypedResults, route groups, filters, .NET 10 validation, OpenAPI and AOT.
  3. REST API Design Best Practices with ASP.NET CoreREST API design best practices for ASP.NET Core: resource naming, HTTP semantics, status codes, ProblemDetails, pagination, ETags, idempotency and versioning.
  4. ASP.NET Core Middleware: Build and Order Your PipelineMaster ASP.NET Core middleware: the RequestDelegate pipeline, Use, Run, Map and UseWhen, correct ordering, custom and IMiddleware components, errors and tests.
  5. Blazor in .NET 10: Render Modes, Components and ArchitectureBlazor in .NET 10 explained: static SSR, streaming, Interactive Server, WebAssembly and Auto render modes, lifecycle, state, forms, JS interop and auth.
  6. Real-Time Web Apps with ASP.NET Core SignalRBuild real-time features with ASP.NET Core SignalR, covering hubs, transports, groups, streaming, authentication, MessagePack and scaling out with Redis.
  7. gRPC in .NET: High-Performance Service CommunicationBuild fast gRPC services in .NET with Protobuf contracts, streaming, client factory, interceptors, deadlines, gRPC-Web, JSON transcoding and load balancing.
  8. Razor Pages vs MVC: Server-Rendered Web Apps in ASP.NET CoreRazor Pages vs MVC in ASP.NET Core: page models, controllers, tag helpers, view components, validation, antiforgery, htmx and when to choose Blazor SSR.
  9. Output Caching, HybridCache and Rate Limiting in ASP.NET CoreSpeed up and protect ASP.NET Core apps with output caching, HybridCache L1/L2 caching and rate limiting: policies, tags, Redis, partitions and 429s.
  10. OpenAPI in ASP.NET Core: Documentation and Client GenerationGenerate OpenAPI 3.1 and 3.2 documents in ASP.NET Core with Microsoft.AspNetCore.OpenApi, transformers, Scalar or Swagger UI, and Kiota or NSwag clients.
  11. YARP: Build Reverse Proxies and API Gateways in .NETBuild reverse proxies and API gateways with YARP, covering routes, clusters, transforms, load balancing, health checks, session affinity and the BFF pattern.

Data Access & EF Core 8

  1. Entity Framework Core: The Complete Guide for .NET DevelopersLearn Entity Framework Core end to end: DbContext, modeling, relationships, migrations, querying, change tracking, complex types, JSON columns and EF Core 10.
  2. EF Core Performance Tuning: Proven Techniques and ChecklistSpeed up EF Core with proven techniques: no-tracking queries, projections, split queries, pooling, compiled queries, bulk updates, indexes and SQL logging.
  3. Dapper and ADO.NET: High-Performance Data Access in .NETLearn when to go below EF Core with ADO.NET and Dapper: readers, pooling, multi-mapping, safe parameters, transactions, Dapper.AOT and SqlBulkCopy.
  4. Database Migrations and Zero-Downtime Schema Changes in .NETShip schema changes safely in .NET: EF Core migrations, bundles, idempotent scripts, CI/CD rollout, expand-contract, backfills, DbUp and FluentMigrator.
  5. SQL Server for .NET Developers: Indexes, Query Plans and TransactionsSQL Server for .NET developers: design indexes, read execution plans, fix parameter sniffing, choose isolation levels, handle deadlocks and use SQL Server 2025.
  6. NoSQL in .NET: A Practical Guide to Azure Cosmos DB and MongoDBNoSQL in .NET with Azure Cosmos DB and MongoDB: document modeling, partition keys, consistency, request units, SDK patterns and EF Core providers.
  7. Caching in .NET: In-Memory, Distributed, Redis and HybridCacheCaching in .NET explained: IMemoryCache, IDistributedCache, Redis and HybridCache, plus invalidation, TTL design, cache keys, serialization and hit ratio.
  8. PostgreSQL with .NET: Npgsql, EF Core and pgvectorA practical guide to PostgreSQL in .NET: Npgsql pooling and multiplexing, EF Core JSONB, arrays, full-text search, COPY imports and pgvector search.

Cloud-Native, Azure & Aspire 9

  1. .NET Aspire 13: Cloud-Native Orchestration for .NETLearn .NET Aspire 13: the AppHost resource model, service defaults, dashboard, Redis and PostgreSQL integrations, testing and deploying with aspire deploy.
  2. Containerizing .NET Applications: Docker Best PracticesBuild small, secure .NET 10 container images with multi-stage Dockerfiles, SDK container publishing, chiseled base images, non-root users and scanning.
  3. Running .NET on Kubernetes: A Production GuideRun ASP.NET Core on Kubernetes in production: health probes, ConfigMaps, GC and CPU limits, graceful shutdown, HPA and KEDA autoscaling, AKS and Helm.
  4. Azure Functions with .NET: Isolated Worker and Durable FunctionsBuild Azure Functions on .NET 10 with the isolated worker: triggers, bindings, Flex Consumption, DI, middleware, Durable Functions patterns and cold starts.
  5. Hosting .NET on Azure: App Service vs Container Apps vs AKSCompare Azure App Service, Container Apps, AKS and Functions for .NET: scaling, cost, networking, Dapr, deployment slots and a clear decision matrix.
  6. Dapr for .NET Developers: Building Blocks for MicroservicesLearn Dapr for .NET: sidecar architecture, service invocation, pub/sub, state, actors, workflows, Aspire, Azure Container Apps and Kubernetes.
  7. Microsoft Orleans: Virtual Actors for Distributed .NET AppsBuild distributed .NET apps with Microsoft Orleans 10: grains, silos, clustering, persistence, reminders, streams, transactions and placement.
  8. OpenTelemetry in .NET: Logs, Metrics and Distributed TracingInstrument .NET apps with OpenTelemetry: ActivitySource traces, Meter metrics, ILogger logs, OTLP export, sampling, propagation and backends.
  9. Resilience in .NET with Polly and Microsoft.Extensions.Http.ResilienceBuild resilient .NET HTTP clients with Polly v8 and Microsoft.Extensions.Http.Resilience: retries, circuit breakers, timeouts, hedging and chaos testing.

Architecture & Design Patterns 9

  1. Clean Architecture in .NET: A Practical GuideClean Architecture in .NET 10 explained: layers, the dependency rule, project layout, use case handlers, validation, mapping, testing and vertical slices.
  2. Domain-Driven Design in C#: Tactical and Strategic PatternsDomain-Driven Design in C#: ubiquitous language, bounded contexts, aggregates, value objects as records, domain events and EF Core 10 mapping patterns.
  3. CQRS and the Mediator Pattern in .NET: MediatR and BeyondCQRS and the mediator pattern in .NET: commands, queries, handlers, pipeline behaviors, MediatR's license change, Wolverine, Mediator and read models.
  4. Event Sourcing in .NET: Concepts and ImplementationEvent sourcing in .NET explained: event stores, streams, projections, snapshots, upcasting, idempotency, Marten, KurrentDB and GDPR crypto-shredding.
  5. Microservices Architecture with .NETMicroservices architecture with .NET: service boundaries, data ownership, gRPC and messaging, gateways, sagas, outbox, OpenTelemetry, Aspire and eShop.
  6. Messaging in .NET: Azure Service Bus, RabbitMQ, Kafka and MassTransitCompare Azure Service Bus, RabbitMQ and Kafka in .NET: delivery guarantees, idempotent consumers, the outbox pattern, dead-lettering and MassTransit.
  7. Modular Monoliths in .NET: Structure, Boundaries and EvolutionBuild a modular monolith in .NET: module boundaries, per-module schemas, in-process messaging and NetArchTest or ArchUnitNET rules that hold as it grows.
  8. Design Patterns in Modern C#Creational, structural and behavioral design patterns in modern C#, built with dependency injection and the patterns already inside the BCL and ASP.NET Core.
  9. Modernizing .NET Framework Applications to Modern .NETA practical roadmap for modernizing .NET Framework apps: assessment, AI-assisted tooling, System.Web adapters with YARP, CoreWCF and EF6 migration.

Performance & Diagnostics 6

  1. High-Performance .NET: Techniques That Actually MatterPractical high-performance .NET techniques: measure first, cut allocations, pick fast collections, vectorize hot loops and tune the GC in .NET 8 to 11.
  2. Benchmarking .NET Code with BenchmarkDotNetLearn to benchmark .NET code correctly with BenchmarkDotNet: core attributes, memory diagnostics, parameters, baselines and CI regression checks.
  3. .NET Diagnostics Toolkit: Counters, Traces and DumpsA practical guide to dotnet-counters, dotnet-trace, dotnet-dump, dotnet-gcdump and dotnet-monitor for diagnosing .NET apps in production.
  4. Finding and Fixing Memory Leaks in .NET ApplicationsHow memory leaks happen in a garbage-collected runtime, the most common causes, and a step-by-step workflow to find and fix them with gcdump and SOS.
  5. Parallel Programming in .NET: TPL, PLINQ and ChannelsA practical guide to parallel programming in .NET with Parallel.For/ForEach, PLINQ, degree of parallelism, System.Threading.Lock and Channels pipelines.
  6. System.Text.Json Deep Dive: Performance, Source Generation and CustomizationA deep dive into System.Text.Json covering JsonSerializerOptions, source generation, custom converters, polymorphism, streaming and security options.

Security & Identity 6

  1. Authentication in ASP.NET Core: Cookies, JWT and OpenID ConnectA practical guide to ASP.NET Core authentication: schemes and handlers, cookies, JWT bearer validation, OpenID Connect with Entra ID, and the BFF pattern.
  2. Authorization in ASP.NET Core: Roles, Claims, Policies and Resource-Based AccessLearn ASP.NET Core authorization in depth, covering roles, claims, policy requirements and handlers, resource-based checks, permissions and testing.
  3. ASP.NET Core Identity vs Entra ID vs External IdPs: Choosing an Identity StackCompare ASP.NET Core Identity, Microsoft Entra ID, Duende IdentityServer, OpenIddict, Keycloak, Auth0 and Okta to pick an identity stack.
  4. OWASP Top 10 for .NET DevelopersA code-first tour of the OWASP Top 10:2025 risks, with concrete ASP.NET Core, EF Core and C# mitigations for access control, injection and more.
  5. Secrets Management in .NET: User Secrets, Key Vault and Managed IdentityHow to keep credentials out of .NET source control using user secrets, Azure Key Vault, managed identity, workload identity and rotation.
  6. Cryptography and Data Protection in .NETA practical guide to cryptography in .NET, covering the Data Protection API, password hashing, AesGcm, RSA/ECDsa and post-quantum APIs.

Desktop, Mobile & Cross-Platform UI 6

  1. .NET MAUI: Cross-Platform Apps with C# and XAMLBuild .NET MAUI apps for Android, iOS, macOS and Windows with C# and XAML: handlers, MVVM Toolkit, Shell, performance and what's new in .NET 10.
  2. WPF in Modern .NET: MVVM, Community Toolkit and Fluent ThemeA practical guide to WPF on .NET 8 to 10: MVVM with CommunityToolkit.Mvvm source generators, generic host DI, the Fluent theme and migration tips.
  3. WinUI 3 and the Windows App SDKWinUI 3 and the Windows App SDK explained: packaged vs unpackaged apps, windowing, app lifecycle, Fluent controls, Windows AI APIs and deployment.
  4. Blazor Hybrid: Web UI in Native .NET AppsLearn Blazor Hybrid and BlazorWebView in .NET MAUI, WPF and Windows Forms: sharing Razor class libraries, native APIs, security and performance.
  5. Windows Forms in Modern .NET: Is It Still Relevant in 2026?Windows Forms still runs on .NET 8 through 10. See what changed: dark mode, high-DPI, async forms, MVVM data binding and migration from .NET Framework.
  6. Choosing a .NET UI Framework: MAUI vs Avalonia vs Uno vs BlazorMAUI, Avalonia, Uno Platform, Blazor, WPF and WinUI 3 compared: platforms, rendering, licensing and tooling, with a decision guide for a .NET UI stack.

Testing, Tooling & DevOps 6

  1. Unit Testing in .NET: xUnit, NUnit, MSTest and MockingA practical guide to unit testing in .NET with xUnit v3, NUnit, MSTest, Microsoft.Testing.Platform, mocking with NSubstitute and Moq, and assertions.
  2. Integration Testing ASP.NET Core with WebApplicationFactory and TestcontainersIntegration test ASP.NET Core with WebApplicationFactory, real databases via Testcontainers, Respawn resets, auth mocking and Aspire's testing builder.
  3. CI/CD for .NET with GitHub Actions and Azure DevOpsBuild production-ready .NET CI/CD pipelines with GitHub Actions and Azure Pipelines: caching, matrix builds, containers, OIDC and approvals.
  4. MSBuild and the .NET Project System: Directory.Build.props and CPMMaster MSBuild, SDK-style projects, Directory.Build.props, Central Package Management, multi-targeting, the .slnx format and binary logs.
  5. Creating and Publishing NuGet Packages the Right WayPublish high-quality NuGet packages: metadata, SemVer, SourceLink, deterministic builds, trusted publishing, NuGet Audit and package signing.
  6. Code Quality in .NET: Analyzers, EditorConfig and Static AnalysisEnforce .NET code quality with built-in analyzers, EditorConfig, TreatWarningsAsErrors, dotnet format and third-party static analysis tools.