.NET Aspire is a set of tools, templates, and packages designed to help developers build observable, production-ready apps that embrace cloud-native and distributed computing best practices. .NET Aspire 9.0 marks a significant evolution, introducing support for both .NET 8 (LTS) and .NET 9 (STS), along with community-driven improvements, enhanced tooling, and richer dashboards.

Key Highlights

• .NET 8 and .NET 9 Compatibility:
  .NET Aspire 9.0 supports both .NET 8 LTS and .NET 9 STS, giving you the flexibility to adopt whichever runtime best suits your organization's support and innovation needs.

• Community-Driven Enhancements:
  Many of .NET Aspire 9.0’s features are guided by community feedback. Join the conversation on Discord or contribute on GitHub to help shape the future of .NET Aspire.

Upgrading and Tooling

Easier Upgrades to Aspire 9.0:
Upgrading to .NET Aspire 9.0 from previous versions is now simpler. The official upgrade guide provides detailed steps, whether you’re upgrading manually or using the Upgrade Assistant.

Simplified Tooling Setup:
Previously, .NET Aspire depended on installing workloads. In .NET Aspire 9.0, you can install the new SDK directly into your app host project, streamlining environment configuration and setup.

Templates from NuGet Packages:
Templates for creating new .NET Aspire projects have moved to separate NuGet packages. Installing templates now uses dotnet new install Aspire.ProjectTemplates::9.0.0, giving you more control over versioning and updates. If you still have the old Aspire workload installed, add --force to overwrite existing templates.

Dashboard and UX Enhancements

Resource Lifecycle Management:
You can now start, stop, and restart individual resources directly from the .NET Aspire dashboard. This granular control helps you debug and manage complex applications without restarting everything. When debugging is attached, it reattaches on restart.

Mobile-Responsive Dashboard:
The Aspire dashboard adapts to various screen sizes, improving accessibility and usability on mobile devices.

Sensitive Property Masking and Enhanced Logs:
Mark properties as sensitive to automatically mask them in the dashboard, preventing accidental exposure of secrets. Colorful console logs now properly render combined ANSI escape codes, providing richer and more informative logs.

Telemetry and Observability

Improved Telemetry Filtering and Browser Support:
Telemetry filtering now supports attribute-based filters with autocompletion, making it easier to focus on relevant traces. You can also combine telemetry from multiple resource replicas and even send telemetry directly from browser-based SPAs into the Aspire dashboard, providing unified observability across clients and servers.

App Host and Orchestration

Waiting for Dependencies and Health Checks:
Resources can now wait for dependencies to become ready before starting, leveraging standard .NET health checks. Add HTTP health checks or custom logic to ensure reliable startup sequences. Health check details appear directly in the dashboard.

Persistent Containers and Resource Commands:
Persistent containers continue running outside the app host lifecycle, ideal for scenarios like databases you don’t want to tear down after testing. Also, define custom commands for resources, enabling additional lifecycle or operational tasks accessible via the dashboard’s UI.

Eventing Model and Container Networking:
Hook into global or resource-specific lifecycle events for more customization. All containers now share a default network, simplifying inter-container communication. Converting from Docker Compose becomes more straightforward.

Integrations and Azure Enhancements

Redis Insight and OpenAI Support (Preview):
Integrate Redis Insight for better database observability and configure OpenAI clients more flexibly, choosing between Azure OpenAI or official OpenAI REST endpoints seamlessly.

MongoDB Credentials, Improved Azure Resource Naming and Lifecycles:
MongoDB integrations now allow specifying credentials. Azure resource customization, previously experimental, is now stable. Adjusting naming policies ensures smoother transitions from .NET Aspire 8 to 9.

Azure Functions (Preview):
One of the most requested features, Azure Functions support, is now in preview. Create and run Azure Functions projects in an Aspire host, debug locally, and deploy to Azure Container Apps seamlessly. Initially supporting common triggers like HTTP, queues, blobs, and service bus, it aligns with .NET Aspire’s goal of simplifying distributed and serverless scenarios.

Customization of Azure Container Apps:
Customize Azure Container App definitions without editing Bicep by using the provided APIs. Scale containers, adjust replicas, and tailor your ACA environment programmatically.

Conclusion

.NET Aspire 9.0 takes another step toward a streamlined, production-ready developer experience. With support for the latest .NET runtimes, a richer dashboard, robust health checks, flexible telemetry, and broader integration capabilities, Aspire 9.0 helps you build, operate, and manage complex distributed applications with confidence and clarity. Whether you’re leveraging .NET 8 LTS stability or embracing .NET 9 innovations, Aspire 9.0 has you covered.

This completes our comprehensive look at what’s new across .NET 9, from runtime and languages to libraries, tooling, MAUI, EF Core, ASP.NET Core, ML.NET, SDK improvements, and finally .NET Aspire 9.0. Together, these advancements illustrate a rapidly maturing, increasingly powerful ecosystem that empowers developers to ship robust, scalable, and innovative solutions.

Are you planning to upgrade to .NET 9 or will stay at .NET 8? What features are most exciting to you? Let me know in the comments.

Subscribe to the blog to stay updated on the latest .NET developments!

Follow on social media:

• Twitter/X: @punskaari
• LinkedIn: @iSatishYadav

The .NET 9 SDK introduces several new capabilities and improvements to streamline development workflows, enhance build and test experiences, improve NuGet security and performance, and provide greater flexibility in managing .NET workloads and containers. These updates make the overall .NET ecosystem more productive, secure, and maintainable.

Unit Testing Improvements

Run Tests in Parallel:
With deeper MSBuild integration, dotnet test can now run tests for the same project across different target frameworks in parallel by default. Parallel test execution scales with the number of available processors, boosting test throughput. You can opt out by setting the TestTfmsInParallel property to false.

Enhanced Test Output in Terminal Logger:
The MSBuild terminal logger now supports test result reporting, offering richer feedback both during test execution (showing currently running tests) and after (improved formatting of test failures). This integrated experience replaces multiple loggers with a single, unified output.

.NET Tool Roll-Forward

Previously, .NET global or local tools didn’t always run on newer .NET versions unless tool authors opted in. In .NET 9, you can specify --allow-roll-forward when installing or running a tool. This option configures the tool to run on a newer major version of .NET if the exact target version isn’t available, providing greater flexibility and future-proofing for early adopters.

Terminal Logger Enhancements

The terminal logger, introduced in .NET 8, is now the default for build, test, and related commands in .NET 9. Enhancements include:

• Enabled by Default: No need to manually enable it; it provides clickable links, color-coded warnings and errors, and more concise, user-friendly output.
• Summaries for Failures and Warnings: The logger now shows total warnings and errors at the end of a build, making it easier to track regressions and understand build quality trends.
• Improved Multi-line Message Rendering: Long warnings or errors now appear without repeated file/line prefixes, resulting in cleaner and more readable output.

You can still disable it with --tl:off or control behavior through environment variables.

NuGet Security Audits and Performance

Auditing Transitive Dependencies by Default:
Starting with .NET 9, dotnet restore audits all package references (including transitive) for known vulnerabilities. This enhances supply-chain security by default, catching more issues early.

Faster Dependency Resolution:
The NuGet dependency resolver in the SDK has been overhauled for better performance and scalability, especially beneficial for large repositories. If you encounter issues with the new resolver, you can revert to the legacy mechanism, but the default experience should yield significant performance gains.

MSBuild Script Analyzers (BuildChecks)

A new feature called BuildChecks helps identify defects and regressions in your build scripts. By passing /check to commands like dotnet build, you enable checks that can produce diagnostics for known issues. This feature makes build scripts more maintainable and reliable over time.

Analyzer Mismatch Mitigation

When running mixed SDK and MSBuild versions, Roslyn analyzers can encounter version mismatches. .NET 9 detects torn SDK scenarios and implicitly downloads a support package (Microsoft.Net.Sdk.Compilers.Toolset) to ensure consistent analyzer experiences, preventing related build warnings and errors.

Workload Sets

Workload sets enable you to pin all installed workloads to a single, stable version until you explicitly update. This approach prevents unintentional updates and ensures consistent workload environments. You can choose your mode (manifests or workload-set) and easily review current mode status and installation history using dotnet workload config and dotnet workload history.

Workload History

dotnet workload history provides a timeline of workload installation and modifications for a given SDK installation. This feature helps you understand how workloads have evolved over time, making it easier to revert or audit changes.

Container Support

Insecure Registries:
The SDK can now publish images to insecure registries. By configuring your Docker or Podman environment and setting DOTNET_CONTAINER_INSECURE_REGISTRIES, you can push images to non-TLS or self-signed registries for development and testing scenarios.

Environment Variable Renaming:
Environment variables controlling container publishing now start with the DOTNET_ prefix instead of SDK_. Existing names remain supported for now.

Code Analysis

.NET 9 adds several new code analyzers and fixers to maintain best practices and improve code quality. New rules include guidance on not passing unnecessary length arguments, advising internal over public types in executables, and ensuring proper usage of hashing APIs, HTTP headers, and streams. For example:

• CA1872: Prefer Convert.ToHexString over BitConverter.ToString for encoding bytes to hex.
• CA2265: Avoid comparing Span<T> to null or default.
• CA2022: Avoid partial reads with Stream.Read by checking return values.

These rules help keep code robust, efficient, and aligned with .NET best practices.

In summary, the SDK and tooling improvements in .NET 9 focus on accelerating feedback loops (faster tests, better terminal output), strengthening security (enhanced NuGet auditing), providing more stable build environments (workload sets, build checks), and granting developers flexibility in container scenarios and runtime configurations. These enhancements streamline daily workflows, reduce complexity, and empower developers to maintain high-quality, secure, and performant .NET applications.

Next → What’s New in .NET Aspire 9.0

Subscribe to the blog to stay updated on the latest .NET developments!

Follow on social media:

• Twitter/X: @punskaari
• LinkedIn: @iSatishYadav

.NET 9 adds a wide range of enhancements and new APIs across the base class libraries. These improvements touch everything from low-level data structures and cryptography to JSON serialization, text processing, spans, and advanced math capabilities. The updates enhance performance, security, flexibility, and developer convenience.

Base64Url Encoding

.NET 9 introduces the new Base64Url class, which encodes/decodes data into a Base64 variant safe for URL use. This variant avoids the + and / characters present in standard Base64, providing a more suitable encoding for query strings and other URL contexts.

ReadOnlySpan<byte> data = ...;
string encoded = Base64Url.EncodeToString(data);

Removal of BinaryFormatter

BinaryFormatter is now removed from .NET 9 runtime implementations. Although the APIs still exist, their usage throws exceptions unconditionally. If your application relies on BinaryFormatter, consider migrating to safer and more modern serialization alternatives. For guidance, see the BinaryFormatter migration documentation.

Collections Improvements

Span-based Lookups:
New capabilities let you look up keys in Dictionary<TKey,TValue> and HashSet<T> using spans, removing the need to allocate strings. With Dictionary<TKey,TValue>.GetAlternateLookup<ReadOnlySpan<char>>(), you can efficiently count words or handle other scenarios with high-performance text processing.

OrderedDictionary:
A new OrderedDictionary<TKey,TValue> provides a generic, efficient type for maintaining insertion order while still offering dictionary-level lookups.

PriorityQueue.Remove():
PriorityQueue<TElement,TPriority> now includes a Remove method that allows emulating priority updates by removing and re-enqueuing items with a new priority, useful in graph algorithms and similar scenarios.

ReadOnlySet:
ReadOnlySet<T> provides a read-only wrapper for sets, similar to how ReadOnlyCollection<T> and ReadOnlyDictionary<TKey,TValue> work for their respective collections.

Component Model and TypeDescriptor Trimming Support

For trimming scenarios, TypeDescriptor introduces new opt-in APIs that register types and fetch properties without triggering trimming warnings. This makes self-contained trimmed applications easier to build without losing type information.

Cryptography Enhancements

CryptographicOperations.HashData():
A new HashData method provides a one-shot hashing API for dynamically chosen algorithms. It streamlines hashing flows and reduces allocations.

KMAC Algorithm:
KMAC (KECCAK-based Message Authentication Code) is now supported, enabling keyed hashing with high-security scenarios. KMAC is available where supported by OpenSSL 3.0 or Windows 11 Build 26016+.

AES-GCM and ChaChaPoly1305 on iOS/tvOS/MacCatalyst:
IsSupported properties for these algorithms now return true on these Apple platforms, expanding cryptographic coverage on mobile and desktop Apple devices.

X.509 Certificate Loading:
A new X509CertificateLoader class provides a "one method, one purpose" approach to loading certificates, avoiding content-sniffing and reducing complexity.

OpenSSL Providers:
You can now open keys via OpenSSL providers (like tpm2, pkcs11), improving hardware security integration scenarios.

Windows CNG VBS:
New flags in CngKeyCreationOptions enable using virtualization-based security (VBS) for keys in Windows 11, enhancing key protection against admin-level attacks.

Date and Time: New TimeSpan.From* Overloads

To avoid floating-point imprecision, new integer-based TimeSpan creation methods allow specifying days, hours, minutes, seconds, milliseconds, and microseconds without floating-point inaccuracies.

TimeSpan ts = TimeSpan.FromSeconds(seconds: 101, milliseconds: 832); // Precise 00:01:41.832

Dependency Injection Improvements

ActivatorUtilities.CreateInstance constructor resolution now correctly prioritizes constructors marked with [ActivatorUtilitiesConstructorAttribute]. This ensures that the specified constructor is always chosen.

Diagnostics and Instrumentation

Debug.Assert Condition Reporting:
If no message is provided, Debug.Assert now includes the textual representation of the failed condition, aiding debugging.

New Activity.AddLink Method:
You can now add links to tracing Activity objects after creation, aligning .NET’s diagnostic APIs better with OpenTelemetry standards.

Metrics.Gauge Instrument:
A new Gauge<T> instrument supports non-additive metric values (like temperature readings or sound levels), following OpenTelemetry specifications.

Out-of-Proc Meter Wildcard Listening:
Meter events can now be listened to via wildcard characters or prefixes, simplifying scenario-specific metric collection with external tools.

LINQ Extensions

CountBy and AggregateBy:
New LINQ methods CountBy and AggregateBy streamline operations that previously required GroupBy. They allow keyed counting and aggregations without allocating intermediate groupings.

Index():
Index enumerates over collections with their indices, simplifying zero-allocation indexing of sequence elements.

Logging Source Generator

The logging source generator now supports classes with primary constructors, allowing for more concise and efficient logging code in C# 13.

Miscellaneous Language Features

C# 13 introduces allows ref struct constraints. Many core library APIs now support ref struct generic parameters. SearchValues expansions improve substring searching and advanced text processing. These enhancements provide more efficient and flexible options for parsers, serializers, and compilers.

Networking Updates

SocketsHttpHandler in HttpClientFactory:
HttpClientFactory now defaults to SocketsHttpHandler for better control and performance of connection pooling and rotation.

System.Net.ServerSentEvents:
A new parser simplifies consuming Server-Sent Events (SSE), aiding scenarios like streaming output from AI services or notifications from servers.

TLS Resume with Client Certificates on Linux:
TLS session resumption with client certificates is now supported on Linux, improving security and performance for mutual TLS scenarios.

WebSocket Keep-Alive and Timeout:
WebSocket APIs now support keep-alive pings and connection abortion on non-responses, ensuring more robust WebSocket connections.

Reflection and Emission

PersistedAssemblies:
PersistedAssemblyBuilder enables generating and saving emitted assemblies to disk, bridging gaps in dynamic assembly creation and code generation scenarios.

TypeName Parsing:
The new TypeName class offers a parseable, reflection-like representation of type names that doesn’t require runtime environment involvement, simplifying advanced serializer and compiler scenarios.

Regular Expressions

[GeneratedRegex] on Properties:
Regex source generation now supports partial properties, in addition to partial methods, for compile-time Regex creation.

Regex.EnumerateSplits:
Regex.EnumerateSplits provides allocation-free span-based splitting with ranges, a significant performance enhancement over Regex.Split.

System.Text.Json Improvements

Indentation Options:
Fine-grained control over indentation character and size for pretty-printed JSON.

JsonSerializerOptions.Web:
A built-in singleton for ASP.NET Core–style serialization defaults (camelCase, etc.).

JsonSchemaExporter:
Generate JSON schemas for .NET types, aiding OpenAPI and AI integration scenarios.

Respect Nullable Annotations and Required Constructor Parameters:
Options RespectNullableAnnotations and RespectRequiredConstructorParameters allow strict enforcement of nullability and constructor invariants during serialization.

Order JsonObject Properties, Custom Enum Names, Multiple JSON Documents, and More:

• Ordered dictionary–like APIs for JsonObject.
• JsonStringEnumMemberNameAttribute for custom enum member names.
• Multi-document support in Utf8JsonReader.

Spans and Memory Efficiency

File Helpers for Spans:
Write spans directly to files with File.WriteAllText(ReadOnlySpan<char>) and other overloads, avoiding allocations.

params ReadOnlySpan Overloads:
Over 60 new or updated APIs now use params ReadOnlySpan<T> for improved performance without array allocations.

Split Enumeration for Spans:
ReadOnlySpan<char>.Split now has enumerator APIs for unknown segment counts, removing the need for allocations.

System.Formats

TarEntry.DataOffset now lets you discover the real location of TAR entry data in a stream, supporting advanced large-file scenarios and concurrent reads.

System.Guid

Guid now supports Version 7 GUID generation, producing time-based, sort-friendly GUIDs. Use Guid.CreateVersion7() for such identifiers.

System.IO and Compression

Transition to zlib-ng for more efficient compression. New compression option types for ZLib and Brotli allow fine-tuned compression level and strategy selection.

System.Numerics

BigInteger Limit:
A new bit-length limit ensures BigInteger operations remain consistent and well-defined.

New BigMul APIs, Vector Conversion/Create APIs, and Accelerations:
Better numeric APIs, faster vector operations, and more built-in SIMD optimizations.

Tensors for AI

Tensor:
A new tensor type enabling efficient data manipulation and interoperability with ML frameworks. Build on TensorPrimitives and other AI-tailored APIs for zero-copy integrations and higher-dimensional computations.

Threading

Task.WhenEach:
Process tasks as they complete using await foreach.

Prioritized Channels:
Channel.CreateUnboundedPrioritized supports elements ordered by priority, not just FIFO.

Interlocked on More Types:
Interlocked now supports byte, sbyte, short, and ushort, and the generic constraints have been relaxed to support primitive and enum types as well.

This extensive set of enhancements in the .NET libraries for .NET 9 caters to performance-focused developers, modern security and cryptography needs, next-gen ML and AI workloads, improved JSON and diagnostics, and more. The changes make the base class libraries more consistent, powerful, and ready for complex, data-intensive scenarios.

Next → What’s New in the SDK and Tooling for .NET 9

Subscribe to the blog to stay updated on the latest .NET developments!

Follow on social media:

• Twitter/X: @punskaari
• LinkedIn: @iSatishYadav

.NET Multi-platform App UI (.NET MAUI) in .NET 9 focuses on improving overall product quality, test coverage, performance, and stability. While previous releases introduced major new capabilities and controls, the emphasis in .NET 9 is on refining the developer experience, ensuring robust cross-platform performance, and preparing the ecosystem for future enhancements.

Enhanced Quality and Compatibility

Key improvements in .NET MAUI 9 revolve around comprehensive bug fixes, expanded test coverage, and enhanced end-to-end scenario testing. The product quality investments are detailed in the official release notes:

• .NET MAUI 9
• .NET MAUI 9 RC2
• .NET MAUI 9 RC1
• .NET MAUI 9 Previews

Note on Support Policy:
Working with external dependencies like Xcode and Android SDK tools influences .NET MAUI’s support policy, which differs from the standard .NET support lifecycles. For more information, see the .NET MAUI support policy.

Minimum Deployment Targets and Tooling Requirements:

• Xcode 16 compatibility is required for building iOS, iPadOS, tvOS, and macOS apps. Xcode 16 requires macOS 14.5 or later.
• Deployment targets: iOS 12.2 and Mac Catalyst 15.0 (macOS 12.0) are now minimum targets, while Android and Windows remain unchanged.

Workload and NuGet Packages:
.NET MAUI ships as both a .NET workload and multiple NuGet packages, enabling developers to pin projects to specific versions or try experimental builds seamlessly. New projects automatically include the required NuGet dependencies.

New Controls

HybridWebView:
The new HybridWebView control allows you to host rich web content (HTML, JS, CSS) within your .NET MAUI app and communicate bidirectionally between JavaScript and C# code. This is ideal for integrating existing React, Vue, or Angular web apps into a cross-platform native shell, leveraging .NET on the back-end.

TitleBar for Windows:
A new TitleBar control lets you create a custom title bar for Windows apps. You can add search bars, icons, and menus directly into the title bar area, improving the UI/UX of your desktop apps. Mac Catalyst support will arrive in a future release.

Control Enhancements and Behavioral Changes

• BackButtonBehavior Binding Mode:
  In Shell apps, IsVisible and IsEnabled on BackButtonBehavior now default to OneWay, making runtime control of the back button easier via data bindings.

• BlazorWebView Updates:
  By default, the BlazorWebView now uses 0.0.0.1 instead of 0.0.0.0 for hosting content. The underlying disposal behavior has also changed to reduce deadlocks, but you can revert to the legacy behavior if needed.

• iOS Buttons:
  Button layout on iOS now more accurately respects spacing, padding, border width, and margins. Images in buttons are sized to the max available space.

• CollectionView & CarouselView (iOS & Mac Catalyst):
  Optional new handlers based on UICollectionView APIs offer improved performance and stability. Opt into these handlers to enhance your list and carousel performance.

• Soft Keyboard Input:
  New keyboard types (Password, Date, and Time) are supported on Entry and Editor controls, enabling more precise input scenarios.

• Text Justification:
  Text controls now support Justify alignment, letting you distribute text evenly across the width of the container.

• TimePicker Event:
  TimePicker adds a TimeSelected event for handling changes in selected time values.

• WebView Process Termination Handling:
  WebView introduces a ProcessTerminated event to handle unexpected web process endings and recover gracefully.

Compiled Bindings and Performance

Compiled Bindings in Code:
.NET MAUI 9 introduces a Func-based approach for defining bindings in code without string paths, improving performance and compile-time validation. Compiled bindings now also support scenarios previously unsupported, like Source-based bindings and multi-bindings.

XAML Compiled Bindings:
XAML compiled bindings have fewer restrictions—bindings that set the Source property and multi-bindings are now supported. By default, non-compiled bindings produce build warnings, encouraging you to adopt compiled bindings for better performance and correctness.

Dependency Injection and Handler Disconnection:
In Shell apps, page registration with the DI container is no longer mandatory unless you’re customizing lifetime behavior. Handlers now disconnect from their controls automatically in most scenarios (for example, when navigating back), but you can override this with a disconnect policy if desired.

Platform-Specific Improvements and Features

Multi-Window Activation:
On Mac Catalyst and Windows, you can activate a specific window using Application.Current?.ActivateWindow(window).

Native AOT Deployment (iOS and Mac Catalyst):
Opt into Native AOT deployment to reduce app size (up to 2.5x smaller), improve startup times (up to 2x faster), and enhance performance. This requires full trim compatibility and no linker warnings.

Native Embedding:
.NET MAUI 9 includes full APIs for native embedding scenarios. You can now easily wrap a .NET MAUI view and present it as a native view on Android, iOS, or Mac Catalyst.

Project Templates, Trimming, and Deprecated APIs

New Project Templates:
The .NET MAUI App project template now includes a sample todo app that uses Syncfusion Toolkit controls and SQLite if you opt in, as well as a .NET MAUI Blazor Hybrid and Web App project template.

Full Trimming Support:
Full trimming support is now available. Trimming-incompatible features are removed unless you specify trimmer directives or adopt compiled bindings and new approaches for XAML and data binding.

Deprecated APIs:

• Frame is obsolete; use Border instead.
• MainPage property on Application is obsolete; set the initial page via Window.Page.
• Legacy measure calls and compatibility layout classes are deprecated.
• Certain hybrid features and dynamic serialization are incompatible with full trimming, and you must use feature switches or alternate patterns.

Upgrading from .NET 8 to .NET 9

To upgrade, update your Target Framework Monikers (TFMs), adopt compiled bindings, remove reliance on deprecated APIs, and consider enabling full trimming and Native AOT where beneficial. Detailed guidance is provided in the official migration instructions.

In short, .NET MAUI 9 concentrates on quality, stability, and performance improvements, making it easier than ever to build high-quality, well-performing cross-platform apps. The introduction of HybridWebView, TitleBar, enhanced bindings, and improved platform integration paves the way for more flexible and efficient MAUI development moving forward.

Next → What’s New in .NET Libraries for .NET 9

Subscribe to the blog to stay updated on the latest .NET developments!

Follow on social media:

• Twitter/X: @punskaari
• LinkedIn: @iSatishYadav

ML.NET continues to evolve as a full-featured, open-source machine learning framework for .NET developers, enabling you to create, train, and deploy custom ML models directly in your .NET applications. ML.NET 3.0 and 4.0 bring expanded capabilities for advanced AI scenarios—particularly around deep learning tasks, AutoML improvements, and enhanced tokenization support—making it easier to handle complex text and vision problems.

New Deep-Learning Tasks

Deep Learning with TorchSharp
ML.NET 3.0 introduces support for several new deep-learning tasks backed by TorchSharp, a .NET library for PyTorch-based deep learning. These tasks include:

• Object Detection: Automatically identify objects within images, assigning bounding boxes and categories. This enables a range of computer vision scenarios, from product detection in e-commerce images to recognizing signs in autonomous driving footage.
• Named Entity Recognition (NER): Extract entities like names, places, organizations, and more from text. NER models streamline text processing, making it easier to process documents, support chatbots, and enhance search functionality.
• Question Answering (QA): Build systems capable of reading comprehension—answering questions about given documents or passages. This feature has significant implications for building chatbots, documentation Q&A tools, and intelligent search solutions.

All these trainers are included in the Microsoft.ML.TorchSharp package. For more details, check out the Announcing ML.NET 3.0 post.

AutoML Enhancements

AutoML (Automated Machine Learning) simplifies model selection and hyperparameter tuning by automating the training and evaluation pipeline. ML.NET 3.0 updates the AutoML sweeper to handle new tasks, including sentence similarity, question answering, and object detection. With these improvements, you can quickly experiment with various models and configurations using the AutoML API, reducing the time and expertise required to achieve state-of-the-art results.

For more information, see How to use the ML.NET Automated Machine Learning (AutoML) API.

Enhanced Tokenizer Support

Text tokenization is a crucial step in NLP pipelines, splitting raw text into manageable tokens (words, subwords, or symbols) before feeding it into language models. In ML.NET 4.0, the Microsoft.ML.Tokenizers package introduces significant enhancements:

• Refined APIs and Tiktoken Support:
  The tokenizer library now supports Tiktoken (the tokenization method used by OpenAI models), enabling more accurate and efficient tokenization for GPT models, such as GPT-4. This lets you integrate local or remote AI services easily, better understand your costs (e.g., Azure OpenAI tokens), and manage prompt context sizes.

• Llama Model Tokenizer:
  The library now supports tokenizing text for Llama-based models, enabling usage of models like LLaMA and Mistral with minimal extra tooling.

• CodeGen Tokenizer:
  With support for CodeGen tokenizers (compatible with models such as codegen-350M-mono and phi-2), you can tokenize code-oriented data and build advanced coding assistants or code-search solutions.

• Span-based APIs and Flexible Normalization:
  New overloads accept Span<char> inputs and allow you to toggle normalization and pretokenization steps. These capabilities give fine-grained control over how text is processed, improving performance and adaptability for various NLP workflows.

• Migration from DeepDev or SharpToken:
  The ML.NET tokenization ecosystem has consolidated around Microsoft.ML.Tokenizers. If you’ve previously used DeepDev or SharpToken, a migration guide is provided to help you smoothly transition to Microsoft.ML.Tokenizers.

For examples and more details, see Announcing ML.NET 2.0 and the updated tokenization library documentation.

Model Builder in Visual Studio

Model Builder, the Visual Studio extension that provides a UI-based machine learning workflow, now consumes ML.NET 3.0. Starting from Model Builder version 17.18.0, you can leverage newly introduced scenarios like question answering (QA) and named entity recognition (NER) directly within Visual Studio. This streamlines building advanced NLP pipelines without leaving your IDE.

In summary, ML.NET’s recent updates extend the framework’s capabilities into advanced AI tasks such as object detection, NER, and QA, while improving automation via AutoML and simplifying text preprocessing with enhanced tokenization. These updates open the door to more sophisticated and production-ready machine learning solutions directly integrated into your .NET applications.

Next → What’s New in .NET MAUI for .NET 9

Subscribe to the blog to stay updated on the latest .NET developments!

Follow on social media:

• Twitter/X: @punskaari
• LinkedIn: @iSatishYadav

Entity Framework Core 9 (EF9) continues to evolve as the go-to data access technology for .NET, delivering improvements in querying, modeling, migrations, cloud-native integrations, and performance. Building on EF Core 8, EF9 targets .NET 8 but can also be used with .NET 9, giving you flexibility in which runtime you adopt. EF9 introduces significant enhancements for working with Azure Cosmos DB, LINQ translations, hierarchical partition keys, and AOT compilation scenarios. It also brings refinements to migrations, model building, and tooling, ensuring a smoother experience for modern data-driven applications.

Release and Availability

EF9 is scheduled for release in November 2024. Until then, you can use EF9 through daily builds, which contain the latest features and API tweaks. We strongly recommend testing new features against these daily builds to ensure you’re working with the most up-to-date functionality. EF9 supports both .NET 8 (LTS) and .NET 9 (STS), so you can choose the runtime that best fits your needs.

Major Highlights

1. Azure Cosmos DB for NoSQL
EF9 brings a comprehensive overhaul of the Azure Cosmos DB provider, including:

• Efficient Partition-Key-Aware Queries: EF9 automatically detects partition key predicates in LINQ queries, using them to route queries only to the relevant partition. This reduces request units (RUs) and improves performance.
• Point Reads with Partition Keys and IDs: If both partition key and ID are specified, EF can perform a direct, cost-effective point read rather than issuing a full SQL query.
• Hierarchical Partition Keys: EF9 fully supports hierarchical partition keys, allowing you to take advantage of Azure Cosmos DB’s multi-level partitioning for finer-grained data partitioning and performance optimization.
• Expanded LINQ Support: The provider now translates more LINQ operations, supports querying over primitive and non-primitive collections, and offers improved function translations (e.g., string.Contains, date/time components).
• JSON Alignment and Simpler IDs: EF9 uses a more natural JSON mapping, removing discriminators from id fields and changing default discriminator names to $type. This improves interoperability with external systems and better aligns with JSON standards.
• Vector Similarity Search (Preview): Azure Cosmos DB vector search can be integrated with EF9, allowing vector-based semantic searches natively.
• Pagination and Continuation Tokens: Paginate through results efficiently using continuation tokens, rather than relying on costly Skip/Take operations.
• Safer Raw SQL Queries: Use FromSql (rather than FromSqlRaw) for parameterized and safe raw SQL operations.

2. LINQ and Query Translation Improvements
EF9 continues to refine its LINQ provider, improving SQL translation and performance:

• Pre-Compiled Queries and AOT: EF9 introduces experimental support for NativeAOT and pre-compiled queries. LINQ queries can be pre-compiled into interceptors containing SQL and materialization logic, significantly improving startup performance.
• Table and Projection Pruning: EF9 removes unnecessary JOINs and projections, generating cleaner and potentially more performant SQL.
• GREATEST/LEAST Functions: New translations leverage SQL Server 2022’s GREATEST and LEAST functions for simpler and more efficient code.
• Parameterization Control: Control parameterization using EF.Parameter and EF.Constant to force or prevent parameterization, balancing query plan reuse against potential performance gains.
• Inlined Subqueries and Aggregates: Complex queries involving aggregates and subqueries are now translated more naturally, often requiring fewer database round trips.
• Consistent Null and Comparison Semantics: EF9 ensures consistent behavior with nullable comparisons, matching C# semantics and aligning results across different providers.

3. Enhanced Modeling and Compilation
Model building sees new features to reduce startup time and simplify configuration:

• Auto-Compiled Models: EF9 can automatically discover and use compiled models without requiring manual UseModel calls. With MSBuild integration, compiled models are automatically regenerated as the model changes, reducing friction.
• Read-Only Primitive Collections: Beyond arrays and mutable lists, EF9 supports read-only collections and lists of primitive types. This provides more flexibility in designing read-only domain models.
• SQL Server Fill-Factor Support: Configure fill-factor for keys and indexes on SQL Server, controlling how index pages are filled and improving index maintenance and performance.
• More Extensible Conventions: EF9 makes it easier to build custom conventions or extend existing ones, improving control over how models are constructed.

4. Migrations and Seeding
Migrations and database initialization also benefit from enhancements:

• Concurrent Migration Protection: EF9 introduces locking to prevent multiple migrations from running concurrently, protecting your database from corruption.
• Warnings for Non-Transactional Operations: EF9 warns if a migration contains non-transactional operations alongside transactional ones, encouraging safer migration patterns.
• Improved Data Seeding APIs: Use .UseSeeding and .UseAsyncSeeding to conveniently insert initial data during context initialization.

5. Tooling Improvements
The dotnet ef command experiences fewer unnecessary rebuilds, improving developer productivity. The team welcomes feedback to ensure these improvements don’t have unintended consequences.

Other Notable Updates

• HierarchyId Improvements: EF9 introduces sugar methods to easily generate child HierarchyId nodes, making hierarchical data handling more intuitive.
• More Efficient Negation and Conditional Translations: EF9 refines the SQL it generates around logical negations, CASE statements, and conditions, often leading to shorter, more direct SQL.
• Better Azure SQL and Azure Synapse Support: EF9 can now target Azure SQL or Azure Synapse specifically, enabling better SQL generation tailored to these environments.

Conclusion

EF Core 9 represents a substantial leap forward in cloud readiness, performance optimization, AOT integration, and interoperability with JSON-based and vector-based workloads. Whether you’re building with Azure Cosmos DB or optimizing SQL queries on relational databases, EF9 delivers greater control, safer migrations, and improved startup times.

In the next installment, we’ll explore What’s New in ASP.NET Core 9.0, examining how the latest changes improve web development, scaling, and performance on the modern web platform.

Next → What’s new in ASP.NET Core 9.0

Subscribe to the blog to stay updated on the latest .NET developments!

Follow on social media:

• Twitter/X: @punskaari
• LinkedIn: @iSatishYadav

ASP.NET Core 9.0 streamlines delivering static assets, enhances Blazor development workflows, expands built-in OpenAPI capabilities, improves SignalR tracing and AOT support, and refines authentication and authorization features. In addition, the release introduces performance optimizations, improved debugging and metrics, and various quality-of-life improvements for developers.

Static Asset Delivery Optimization

Delivering static assets efficiently is a key part of building high-performance web applications. ASP.NET Core 9.0 introduces MapStaticAssets, a new endpoint convention that can replace UseStaticFiles in most scenarios. This feature leverages build-time preprocessing to compress and optimize your site’s static resources, including CSS and JavaScript files. Benefits include:

• Build-time Compression:
  CSS and JS files are compressed (gzip or brotli) at build time, eliminating the need for on-the-fly compression. This saves CPU cycles and reduces bandwidth usage.

• Content-Based ETags:
  ETag headers are generated based on the file’s SHA-256 hash, ensuring the browser re-downloads a file only if its content changes.

• Caching and Stale Asset Prevention:
  The runtime sets optimal caching headers and uses asset fingerprints to ensure clients get updated content when files change.

MapStaticAssets is ideal for assets known at build and publish time. For more dynamic scenarios or assets served from external sources, UseStaticFiles remains a good fit. By default, the optimization works automatically, providing out-of-the-box size reductions of up to 80–90% compared to uncompressed files. This improvement benefits mobile and low-bandwidth environments significantly.

Blazor Enhancements

.NET MAUI Blazor Hybrid & Web App Solution Template:
A new template allows you to create .NET MAUI native and Blazor Web apps that share the same UI layer. This solution template offers:

• A unified, shared Razor Class Library (RCL) for UI components.
• Automatic generation of a Blazor Web App (global interactivity) and a .NET MAUI Blazor Hybrid app.
• Dependency injection demos to show how to handle environment-specific services.

Detecting Render Modes, Interactivity, and Location:
ASP.NET Core 9.0 provides APIs to detect a component’s execution environment, whether it’s interactive, and which render mode it uses. This makes it easier to write components that behave differently depending on their execution context.

Improved Reconnection for Server-Side Blazor:
The reconnection experience for Blazor Server has been refined:

• Immediate reconnection attempts when revisiting a sleeping tab.
• Automatic page refresh if the server has released the circuit.
• An adaptive backoff strategy for retry intervals and modernized reconnection UI.

Authentication State Serialization:
New APIs make it simpler to add authentication to Blazor Web Apps. You can serialize the authentication state on the server and deserialize it in the browser, enabling pre-initialized authentication states without custom code. This integration works seamlessly with global interactivity and the Individual Accounts authentication scheme.

Static SSR Pages in Globally-Interactive Blazor Apps:
You can now opt certain pages out of global interactivity and render them using only server-side static SSR. This approach is useful for pages that rely heavily on the request/response cycle (for example, operations involving cookies) and cannot be interactively updated.

Constructor Injection in Razor Components:
Razor components now support dependency injection via constructors, providing a familiar and streamlined pattern for injecting services into components.

WebSocket Compression and CSP for Interactive Server Components:
By default, Interactive Server components now use WebSocket compression and set a default CSP frame-ancestors policy. You can disable compression or tighten CSP directives further, balancing security and performance.

Keyboard Composition Events and InputNumber Enhancements:

• KeyboardEventArgs.IsComposing helps handle international character input scenarios more accurately.
• InputNumber<TValue> now supports type="range", enabling range inputs like sliders with integrated form validation and model binding.

Enhanced Navigation Events:
JavaScript callbacks can be triggered before and after “enhanced navigation,” improving how you handle navigation events in Blazor SSR scenarios.

SignalR Improvements

Polymorphic Type Support in Hubs:
Hub methods can accept base classes, allowing polymorphic binding of derived types. Annotate classes with [JsonPolymorphic] and [JsonDerivedType] to enable this scenario.

Tracing with OpenTelemetry:
New ActivitySource instrumentation for both server and client hubs helps with distributed tracing. You can see how methods and calls link together across the network, making debugging and telemetry much easier.

Native AOT and Trimming Support:
SignalR now supports trimming and native AOT scenarios, reducing application size and startup time while maintaining real-time communication capabilities.

OpenAPI Integration

ASP.NET Core 9.0 introduces first-class OpenAPI document generation via Microsoft.AspNetCore.OpenApi. This new capability:

• Generates OpenAPI documents for controller-based or minimal APIs.
• Integrates with the .NET toolchain to generate documents at build time.
• Supports customization through document, operation, and schema transformers.
• Works seamlessly with trimming and native AOT.

Authentication and Authorization Updates

Pushed Authorization Requests (PAR) for OpenID Connect:
The OpenIdConnectHandler now supports Pushed Authorization Requests, improving security by sending authorization parameters through back channels rather than the browser’s front channel. This feature is enabled by default if the Identity Provider supports PAR and can be disabled if necessary.

OAuth/OIDC Parameter Customization:
A new AdditionalAuthorizationParameters option allows adding arbitrary query parameters without writing custom events or handlers.

HTTP.sys Extended Authentication Flags:
Configure Kerberos credential caching and credential capturing via EnableKerberosCredentialCaching and CaptureCredentials options, optimizing Windows authentication scenarios.

Miscellaneous Improvements

HybridCache (Preview):
A new HybridCache API merges the best of IDistributedCache and IMemoryCache with features like stampede protection, customizable serialization, and performance optimizations. It’s intended to simplify caching patterns and minimize duplication of logic.

Developer Exception Page Enhancements:
The developer exception page now includes endpoint metadata, improved text wrapping, and consistent formatting, making debugging easier.

Dictionary Debugging Improvements:
Key-value collections (headers, query strings, cookies, etc.) have improved debugging layouts, making their contents more readable in Visual Studio’s debugger.

Graceful Shutdown with IIS & ANCM:
A built-in delay helps avoid 503 errors during app restarts or recycles on IIS, configurable via shutdownDelay.

Analyzer for Overridden Authorization:
A new analyzer warns when [Authorize] attributes are effectively overridden by [AllowAnonymous] attributes placed farther away, preventing unintentional security lapses.

Connection Metrics and Named Pipe Endpoints in Kestrel:
Kestrel’s improved kestrel.connection.duration metric includes error types, helping diagnose connection issues without verbose logging. Named pipe endpoints now support advanced customization options.

ExceptionHandlerMiddleware Customization:
Configure custom status codes returned by ExceptionHandlerMiddleware based on the exception type.

Opt-Out of HTTP Metrics and Other Features:

• Metrics can be disabled per endpoint or dynamically per request.
• Data protection keys can be deleted after careful consideration.
• Middleware supports keyed DI injection.
• dotnet dev-certs https --trust now works on Linux to trust the ASP.NET Core development certificate in browsers and the system.

Template Updates:
The .NET 9 templates now use the latest versions of Bootstrap, jQuery, and jQuery Validation, ensuring you start with modern, secure, and performant front-end dependencies.

Next → What’s New in ML.NET

Subscribe to the blog to stay updated on the latest .NET developments!

Follow on social media:

• Twitter/X: @punskaari
• LinkedIn: @iSatishYadav

C# 13 introduces a collection of language enhancements that streamline code patterns, enable more powerful generics, improve low-level control, and provide smoother integrations with newer runtime features. These improvements are fully supported on .NET 9, so you can experiment with them using the latest .NET 9 SDK and Visual Studio 2022 releases.

Overview

C# 13 adds multiple new features and relaxes certain restrictions, making it easier to write concise, high-performance, and safe code. Key enhancements include:

• params Collections: Broader support for params with various collection types beyond arrays.
• New Lock Type and Semantics: Integration with the new System.Threading.Lock type for improved synchronization.
• New Escape Sequence \e: A simplified escape sequence for the ESC character.
• Method Group Natural Type Improvements: Refined logic for determining a method group’s natural type.
• Implicit Indexer Access in Object Initializers: Using the ^ operator (from-end indexing) directly in object initializers.
• ref and Unsafe Contexts in Iterators and Async Methods: More flexible usage of ref struct and unsafe contexts in async and iterator methods.
• allows ref struct Anti-Constraint: Enabling ref struct types as generic type parameters.
• Implementing Interfaces on ref struct Types: Allowing ref struct to implement interfaces (with some restrictions).
• Partial Properties and Indexers: Extending partial method concepts to properties and indexers.
• Overload Resolution Priority: Letting library authors prioritize certain overloads.
• Preview: field Contextual Keyword: Introducing a preview feature for directly accessing compiler-generated backing fields.

Each of these changes builds on the language’s existing strengths, providing more expressive and efficient patterns while maintaining safety and compatibility.

params Collections

Previously, the params modifier was restricted to arrays. With C# 13, params can be applied to a broader range of collection types, including System.Span<T>, System.ReadOnlySpan<T>, and any type that implements IEnumerable<T> and has an Add method. This flexibility allows developers to choose data structures that better fit their performance or memory requirements.

For example, you can declare a method that accepts a ReadOnlySpan<T> via params:

public void Concat<T>(params ReadOnlySpan<T> items)
{
    for (int i = 0; i < items.Length; i++)
    {
        Console.Write(items[i]);
        Console.Write(" ");
    }
    Console.WriteLine();
}

When using interface types like IEnumerable<T> as params parameters, the compiler automatically synthesizes the storage for supplied arguments, simplifying code while still providing flexibility.

New Lock Type and Semantics

The .NET 9 runtime introduces a new System.Threading.Lock type for thread synchronization, and C# 13 integrates with it seamlessly. When you use the lock statement on a Lock object, the compiler uses the Lock.EnterScope() API and a ref struct to implement the lock’s scope, rather than relying on System.Threading.Monitor. This leads to more efficient synchronization and aligns lock semantics with the new runtime capabilities—no additional code changes are required aside from using the new type in your lock statements.

New Escape Sequence: \e

The escape character ESC (U+001B) can now be represented with the \e escape sequence. Previously, you had to rely on \u001b or \x1b, which could introduce ambiguity if followed by hexadecimal digits. This new escape sequence removes that ambiguity and makes code clearer:

string message = "\e[31mRed text\e[0m";

Method Group Natural Type Improvements

C# 13 refines how the compiler determines a method group’s natural type. Previously, if the compiler needed a “natural type” for a method group, it considered all candidate methods and their scopes simultaneously, which could lead to convoluted rules and less predictable results.

Now, the compiler prunes non-applicable candidate methods at each scope before moving outward, more closely mirroring standard overload resolution. This change yields more intuitive behavior for complex method group scenarios involving generics and constraints.

Implicit Indexer Access in Object Initializers

C# 13 allows using from-end indexing (the ^ operator) within object initializers, making it easier to express initialization logic that references elements from the end of a sequence. For example:

var countdown = new TimerRemaining()
{
    buffer =
    {
        [^1] = 0,
        [^2] = 1,
        [^3] = 2,
        [^4] = 3,
        [^5] = 4,
        [^6] = 5,
        [^7] = 6,
        [^8] = 7,
        [^9] = 8,
        [^10] = 9
    }
};

This feature eliminates the need to reindex arrays or collections from the front, simplifying initialization for patterns like reverse ordering.

ref and Unsafe Contexts in Iterators and Async Methods

Before C# 13, iterators (yield return) and async methods were more restrictive about ref locals, ref struct usage, and unsafe contexts. C# 13 relaxes these rules, enabling scenarios where:

• Async methods can declare ref local variables or ref struct variables, as long as they don’t cross await boundaries.
• Iterator methods can now contain unsafe contexts, as long as all yield return or yield break statements remain in a safe context.

These changes allow System.Span<T> and similar ref struct types to be more widely used, improving performance without sacrificing safety.

allows ref struct Anti-Constraint

Generic constraints in C# 13 now include the allows ref struct keyword, which permits ref struct types as generic type arguments. This capability makes it possible to write generic algorithms that leverage Span<T> or ReadOnlySpan<T> without resorting to reflection or unsafe code.

For example:

public class C<T> where T : allows ref struct
{
    public void M(scoped T p)
    {
        // p is a ref struct type and must follow ref safety rules
    }
}

This unlocks new avenues for performance-sensitive code that works with stack-based data structures.

Implementing Interfaces on ref struct Types

C# 13 allows ref struct types to implement interfaces. However, a ref struct can’t be converted to the interface type at runtime because that would require boxing, violating ref safety. Furthermore, ref struct types must implement all methods of the interface, including those with default implementations.

This feature closes a gap in type capabilities, enabling ref struct types to adhere to interface contracts without relying on non-ref struct wrappers or complex workarounds.

Partial Properties and Indexers

You can now declare partial properties and indexers, analogous to how partial methods work. One part can declare the signature, while another part provides the implementation. This feature enhances modularity and code organization, especially in large codebases where splitting property or indexer logic across multiple files can improve maintainability.

Overload Resolution Priority

With OverloadResolutionPriorityAttribute, library authors can influence the compiler’s overload resolution to prefer certain overloads over others. This feature helps guide consumers toward newer, more efficient APIs without introducing breaking changes. It should be used judiciously to maintain code clarity.

Preview Feature: field Keyword

C# 13 introduces field as a contextual keyword in property accessors, allowing direct access to the compiler-generated backing field without declaring it explicitly. For example:

public partial class C
{
    public partial string Name { get; set; }
}

public partial class C
{
    public partial string Name
    {
        get => field;
        set => field = value.Trim();
    }
}

This feature is currently in preview, and feedback from developers will guide its final design and adoption.

Getting Started

You can try out these C# 13 features by installing the .NET 9 SDK and using the latest version of Visual Studio 2022. For more details on feature availability, refer to the C# language versioning documentation.

Breaking changes and additional documentation can be found in the breaking changes article and the Roslyn feature status pages, which track when features are merged and their current preview status.

Summary

C# 13 brings a wide range of enhancements that improve language flexibility, performance potential, and developer productivity. Whether you’re working with new runtime features, exploring more efficient synchronization primitives, or leveraging ref struct types in more scenarios, C# 13 provides tools that streamline these tasks.

In the next installment, we’ll look into What’s New in EF Core 9, including updates for Azure Cosmos DB, AOT compilation, and more.

Next → What’s New in EF Core 9

Subscribe to the blog to stay updated on the latest .NET developments!

Follow on social media:

• Twitter/X: @punskaari
• LinkedIn: @iSatishYadav

The .NET 9 runtime introduces a range of features and optimizations aimed at improving performance, reducing application size, enhancing security, and providing more flexible deployment options. These enhancements target both core runtime components and the JIT compiler, delivering faster execution times, smaller footprints, and safer execution environments.

Attribute Model for Feature Switches with Trimming Support

In .NET 9, two new attributes—FeatureSwitchDefinitionAttribute and FeatureGuardAttribute—help developers define feature switches that integrate with trimming and Native AOT. By using these attributes, you can toggle areas of functionality at build time, removing unused code paths and reducing application size.

• FeatureSwitchDefinitionAttribute:
  This attribute treats a feature-switch property as a compile-time constant during trimming. When a feature is disabled in the app’s configuration, related code paths are removed from the final binary. Consider the following code:

  if (Feature.IsSupported)
      Feature.Implementation();
  
  public class Feature
  {
      [FeatureSwitchDefinition("Feature.IsSupported")]
      internal static bool IsSupported => AppContext.TryGetSwitch("Feature.IsSupported", out bool isEnabled) ? isEnabled : true;
  
      internal static void Implementation() { /* ... */ }
  }
  

  By setting <RuntimeHostConfigurationOption Include="Feature.IsSupported" Value="false" Trim="true" /> in the project file, Feature.IsSupported is effectively treated as false, and the call to Feature.Implementation() is removed after trimming.

• FeatureGuardAttribute:
  This attribute identifies a feature-switch property as a guard for code annotated with RequiresUnreferencedCodeAttribute, RequiresAssemblyFilesAttribute, or RequiresDynamicCodeAttribute. For example:

  if (Feature.IsSupported)
      Feature.Implementation();
  
  public class Feature
  {
      [FeatureGuard(typeof(RequiresDynamicCodeAttribute))]
      internal static bool IsSupported => RuntimeFeature.IsDynamicCodeSupported;
  
      [RequiresDynamicCode("Feature requires dynamic code support.")]
      internal static void Implementation() { /* Uses dynamic code */ }
  }
  

  When publishing with <PublishAot>true</PublishAot>, this setup avoids certain analyzer warnings and removes unreachable code paths.

UnsafeAccessorAttribute Support for Generic Parameters

UnsafeAccessorAttribute—introduced in .NET 8—allows direct, unsafe access to private type members. In .NET 9, it now supports generic parameters for both CoreCLR and Native AOT scenarios. This expansion enables reflection-free access to generic fields and methods, improving advanced scenarios like performance-sensitive libraries and frameworks.

using System.Runtime.CompilerServices;

public class Class<T>
{
    private T? _field;
    private void M<U>(T t, U u) { }
}

class Accessors<V>
{
    [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_field")]
    public extern static ref V GetSetPrivateField(Class<V> c);

    [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "M")]
    public extern static void CallM<W>(Class<V> c, V v, W w);
}

With this feature, code that previously relied on reflection to manipulate generics can now use UnsafeAccessorAttribute for more efficient and predictable access.

Garbage Collection Improvements

Dynamic adaptation to application sizes (DATAS), introduced as an opt-in in .NET 8, is now enabled by default. DATAS adjusts memory usage dynamically based on the application’s long-lived data size. This approach helps the GC maintain a heap size proportional to actual memory requirements, improving overall performance and efficiency in real-world workloads.

For more details, see Dynamic adaptation to application sizes (DATAS).

Control-Flow Enforcement Technology (CET)

CET is now enabled by default on Windows, providing hardware-enforced protection against return-oriented programming (ROP) exploits. CET improves application security by enforcing safer control-flow transitions. Although it may introduce a small performance overhead, CET can be disabled if necessary. This marks a significant step in hardening .NET applications against low-level attacks.

.NET Install Search Behavior

.NET 9 adds configuration options for how apps locate and load the .NET runtime. Developers can now more tightly control the search behavior, which is useful for private runtime installations or ensuring a stable, known environment.

Performance Improvements Across the Board

The .NET 9 runtime delivers a wide array of performance optimizations. These improvements span JIT compilation, code generation, loop transformations, exception handling, and more. They include:

• Loop Optimizations:
  Enhanced induction-variable widening, post-indexed addressing on Arm64, strength reduction, and loop counter direction optimizations reduce instruction counts and increase throughput. Common looping patterns—such as iterating over arrays—are now executed more efficiently without any source code changes.

• Inlining Improvements:
  Shared generics that require runtime lookups can now be inlined, reducing overhead and enabling further optimizations. Accesses to thread-local statics on multiple platforms are also more easily inlined, cutting down instruction counts and improving runtime performance.

• PGO Enhancements:
  Dynamic profile-guided optimization (PGO), enabled by default since .NET 8, now drives more decisions, including optimizing type checks and casts based on observed runtime behavior. This leads to faster code paths for the common cases your application actually encounters.

• Arm64 and SIMD Codegen:
  Arm64 benefits from vectorization in .NET libraries, multi-register load/store instructions, post-indexed addressing, and store-pair instructions. AVX10v1 support and Arm SVE experimental support introduce new hardware acceleration paths, allowing .NET to leverage cutting-edge CPU instruction sets for even greater speed-ups.

• Faster Exceptions:
  The exception handling model now mirrors the NativeAOT runtime’s approach, eliminating Windows SEH and Unix emulation. As a result, handling exceptions is up to 2-4 times faster in micro-benchmarks, significantly improving scenarios where exceptions are part of normal execution (for example, certain parsing or cancellation operations).

• Code Layout and Reduced Address Exposure:
  The JIT compiler now rearranges basic blocks more effectively, using profile data to reduce branching. It also tracks addressed-exposed locals more accurately, avoiding unnecessary constraints that limit optimization opportunities.

• Object Stack Allocation for Boxes:
  Situations where value types need to be boxed (for example, passing them as objects) can now be optimized by stack-allocating the box when it doesn’t escape the current method. In some cases, the compiler can even reason about the values and remove the boxes entirely, generating more efficient code and reducing allocations.

Summary

The .NET 9 runtime brings substantial changes under the hood to deliver faster, more secure, and more efficient applications. Developers benefit from:

• Greater control over feature sets and trimming, ensuring leaner deployments.
• Improved performance through advanced JIT optimizations, vectorization, and better code generation strategies.
• Enhanced security via CET and refined exception handling for predictable, safe execution.
• New capabilities that enable low-level code manipulation, improved GC behavior, and better CPU-specific optimizations.

In the next part, we’ll explore What’s new in C# 13, the language updates accompanying this release, and how they integrate with the runtime to provide a more productive and modern development experience.

Next → What’s New in C# 13

Subscribe to the blog to stay updated on the latest .NET developments!

Follow on social media:

• Twitter/X: @punskaari
• LinkedIn: @iSatishYadav

Emphasis on Cloud-Native and Containerized Workloads

Cloud-native architectures and container-based deployments are standard practice for modern applications. .NET 9 aligns with these trends by refining the framework’s capabilities for distributed, scalable systems. This includes adjustments to runtime behavior, library enhancements that streamline serialization and network I/O, and improved integration points for AI and machine learning workloads—all of which are increasingly relevant in orchestrated, cloud-hosted environments.

For example:

• Runtime Adjustments for Cloud Scale: Changes in garbage collection and performance heuristics are designed to better handle highly variable workloads common in cloud scenarios. Dynamic memory management improvements help applications adapt to fluctuating demand without manual intervention.

• Optimized Communication and Serialization: Enhancements in System.Text.Json, such as support for nullable reference type annotations, exporting JSON schemas from types, and new options for customizing JSON indentation, reduce overhead in microservices that frequently communicate using JSON-based payloads.

Performance Improvements from Top to Bottom

Performance has been a central priority across multiple layers of .NET 9:

• Runtime-Level Optimizations: Enhanced code generation, loop optimizations, inlining strategies, and Arm64 vectorization result in more efficient execution paths. The runtime also introduces a new attribute model for feature switches, enabling libraries to toggle functionality at compile or link time, which can shrink binary size and improve startup times.

• Library Improvements: Beyond serialization, improvements to LINQ (like the new CountBy and AggregateBy methods), priority queues (new Remove method for easier priority updates), cryptographic operations (a new CryptographicOperations.HashData and KMAC algorithms), and reflection APIs help developers write faster and more efficient code with fewer allocations and better resource usage.

• Refined Tooling and SDK Features: A more flexible SDK, improved NuGet security audits (now including transitive references by default), and a default-enabled terminal logger enhance the reliability and traceability of builds. The terminal logger provides more concise and usable summaries, making it easier to identify performance regressions or issues in complex projects. Additionally, new MSBuild script analyzers ("build checks") are available to help identify and fix common build-related issues.

AI and Machine Learning Support

As applications increasingly integrate AI-driven features, .NET 9 introduces building blocks that simplify the adoption of machine learning and language model capabilities:

• Microsoft.Extensions.AI and Microsoft.Extensions.VectorData: These packages provide a unified layer of abstractions to interact with AI services, embeddings, vector stores, and middleware. This uniform API surface reduces the complexity of integrating AI features, eliminating the need for custom glue code.

• TensorPrimitives and Tensor: New tensor APIs enable efficient manipulation of multi-dimensional data, crucial for tasks like model inference, image processing, or advanced analytics. These APIs are SIMD-optimized and designed to interoperate efficiently with AI frameworks like ML.NET, TorchSharp, and ONNX Runtime. TensorPrimitives now supports nearly 200 operations (up from 40), generic overloads for different numeric types, and improved performance through SIMD optimizations.

Language Updates and Enhanced Developer Experience

.NET 9 ships with updates to C# (version 13) and F# (version 9), providing language-level features that simplify coding patterns and modernize idioms:

• C# 13: Introduces params collections, a new lock type and semantics, a new \e escape sequence, method group natural type improvements, implicit indexer access in object initializers, ref locals in async and iterator methods, and allows ref struct constraints for generics, along with partial properties and indexers.

• F# 9: Adds nullable reference types, discriminated union .Is* properties, partial active patterns returning bool, improved tooling support, and other performance and productivity enhancements.

These language updates help developers write safer, more maintainable code and take advantage of modern constructs that improve both productivity and safety.

Broad Ecosystem Enhancements

ASP.NET Core 9.0 gains optimizations like handling static files more efficiently at build and publish time, Blazor enhancements (hybrid and web app templates, reconnection improvements), API OpenAPI generation, enhanced native AOT support, and security improvements. ML.NET 4.0 brings improved configuration options, ONNX model loading from streams, tokenizer capabilities, and TorchSharp integration for new model families. .NET MAUI focuses on performance, reliability, Native AOT and trimming enhancements, a new TitleBar control on Windows, and a HybridWebView.

EF Core 9 refines Azure Cosmos DB support, steps towards AOT compilation, and pre-compiled queries, while the libraries add LINQ improvements, JSON schema generation, and reflect new methods like CountBy and AggregateBy.

Windows Presentation Foundation (WPF) and Windows Forms also see enhancements, with modern theming, improved ligature support in fonts, no more BinaryFormatter, and rendering improvements for code generation and debugging scenarios.

Engaging with the Community and Looking Ahead

The .NET team actively posts .NET 9 preview updates and discussions on GitHub, allowing developers to stay informed, ask questions, and provide direct feedback. This open dialogue helps refine features before general availability.

To Learn More:

• Download .NET 9 to begin experimenting with the latest improvements.
• Explore the official documentation for detailed guidance on new APIs, runtime settings, and advanced scenarios.
• Check out .NET 9 GitHub Discussions for ongoing previews, Q&A, and community feedback.

Next → What’s New in the .NET 9 Runtime

Subscribe to the blog to stay updated on the latest .NET developments!

Follow on social media:

• Twitter/X: @punskaari
• LinkedIn: @iSatishYadav

Unprecedented Performance Optimizations

The latest iteration of .NET brings forth several performance optimizations that significantly augment application efficiency and responsiveness:

• Dynamic Profile-Guided Optimization (PGO): Enabling up to a 20% improvement in application performance through real-world usage-based code optimization.

• AVX-512 Support: Empowering parallel operations on 512-bit data vectors, ensuring enhanced data processing capabilities and accelerated computational throughput.

• UTF-8 Formattable and Parsable Interface: Direct UTF-8 formatting and parsing capabilities sans transcoding overhead, fortifying application efficiency and responsiveness.

.NET Aspire: Redefining Cloud-Native Development

.NET Aspire represents a curated collection of components tailored explicitly for cloud-native application development. With an emphasis on resilience, observability, and simplified configuration, it provides:

• Curated Components: Equipped with enhanced telemetry, resilience, configuration, and health check capabilities by default.

• Streamlined Local Developer Experience: Simplified acquisition and configuration of essential dependencies for cloud-native applications, facilitating a seamless development journey.

Augmented Container Capabilities in .NET 8

Containerized application deployment is further fortified in .NET 8, ensuring:

• Enhanced Container Security: Incorporation of non-root users within .NET images, bolstering container security measures.

• Compact Image Sizes: Faster deployment facilitated by minimized .NET base image sizes, optimizing resource utilization.

Native AoT - Facilitating Compute Efficiency

Compile .NET applications into native code to minimize memory footprint and expedite app initialization:

• Compiled Native Code: Immediate app startup without JIT compilation overhead, facilitating operation in restricted environments.

Integrating Artificial Intelligence with .NET

Harness the power of generative AI and large language models, seamlessly integrated into .NET 8:

• Generative AI Integration: Simplified AI integration with first-class out-of-the-box AI features within the .NET SDK.

• System.Numerics Library Enhancements: Enhanced compatibility with Generative AI workloads, integrating Tensor Primitives.

Advanced Web Application Development with Blazor

Blazor in .NET 8 introduces innovative features for comprehensive web UI development:

• Blazor Server and Blazor WebAssembly Integration: Full-stack web UI capabilities merging server and client-side functionalities.

• Robust Authentication and Authorization: Full support for Blazor-based Identity UI, elevating security measures.

.NET MAUI - Unifying Cross-Platform Development

.NET MAUI revolutionizes cross-platform app development, unifying project systems across multiple platforms:

• Unified Project System: Develop WinUI, Mac Catalyst, iOS, and Android applications from a single codebase.

• Quality Improvements: Enhanced performance, controls, UI elements, and platform-specific behaviors.

C# 12 Features - Amplifying Developer Productivity

The introduction of C# 12 brings forth a range of productivity enhancements:

• Primary Constructors: Streamlined class initialization, minimizing boilerplate code.

• Concise Collection Types: Simplified array and span creation, augmenting code readability.

• Lambda Expression Parameter Defaults: Improved handling of optional arguments within lambda expressions.

Broader .NET 8 Support Across Development Tools

Visual Studio 2022 17.8 and Visual Studio Code's C# Dev Kit offer extended support for .NET 8, empowering developers with advanced tooling capabilities across diverse development environments.

Additional new features

• ASP.NET Core: Streamlines identity for single-page applications (SPA) and Blazor providing cookie-based authentication, pre-built APIs, token support, and a new identity UI. Enhances minimal APIs with form-binding, antiforgery support to protect against cross-site request forgery (XSRF/CSRF), and asParameters support for parameter-binding with Open API definitions.

• ASP.NET Core Tooling: Route syntax highlighting, auto-completion, and analyzers to help you create Web APIs.

• Entity Framework Core: Provides new “complex types” as value objects, primitive collections, and SQL Server support for hierarchical data.

• NuGet: Helps you audit your NuGet packages in projects and solutions for any known security vulnerabilities.

• .NET Runtime: Brings a new AOT compilation mode for WebAssembly (WASM) and Android.

• .NET SDK: Revitalizes terminal build output and production-ready defaults.

• WPF: Supports OpenFolderDialog and Enabled HW Acceleration in RDP.

• ARM64: Significant feature enhancements and improved code quality for ARM64 platforms through collaboration with ARM engineers.

• Debugging: Displays debug summaries and provides simplified debug proxies for commonly used .NET types.

• System.Text.Json: Helps populate read-only members, customizes unmapped member handling, and improves Native AOT support.

• .NET Community Toolkit: Accelerates building .NET libraries and applications while ensuring they are trim and AOT compatible (including the MVVM source generators!)

• Azure: Supports .NET 8 with Azure’s PaaS services like App Service for Windows and Linux, Static Web Apps, Azure Functions, and Azure Container Apps.

• F# 8: Includes significant language changes, new diagnostics, improvements in usability, and performance enhancements in project compilation, as well as upgrades to the FSharp.Core standard library.

Conclusion

.NET 8 stands as a testament to continuous innovation, fostering a robust ecosystem for developers to craft high-performance, resilient, and scalable applications across diverse domains. It represents a leap forward in the realm of software development, revolutionizing the way applications are built and optimized.

Embrace the future of development with .NET 8, explore its technical depths, and join my journey at my blog here at https://blog.satishyadav.com

Getting started

• Download .NET 8

• Upgrade your old apps to .NET 8

This course offers a comprehensive introduction to C# programming, covering its core concepts, syntax, and practical application in software development.

Through hands-on exercises and projects, you will learn the fundamentals of C#, including variables, data types, control structures, and object-oriented programming principles.

By the end of this course, you will have gained the practical skills and knowledge needed to confidently leverage C# for building applications.

Is it worth learning C# today?

Well, yes of course! C# continues to be among the World’s top 5 Programming Languages, after Python, C, C++, and Java. Surpassing even JavaScript, Go, and Rust. C# is used not only by Large Enterprises but also in Game Development, Web Development, Cross-Platform Mobile App development and many more.

The certification is completely free.

This new certification’s content is hosted on Microsoft Learn — Microsoft’s learning Platform where hundreds of Microsoft Training and Learning materials are available free of cost.

The official C# certification was missing for a long time as earlier official certification Exam 70-483: Programming in C# had retired in 2021.

Is it for me?

The course has something for everybody, whether you're a seasoned developer working with C# for decades or a newcomer who is just trying their hands dirty with C#. I too, have completed the Course and got the Certificate and I must say it’s comprehensive. It doesn’t require prior C# knowledge but assumes you have some programming sense.

One small weirdness I have observed is, it requires you to go back and forth between freeCodeCamp and Microsoft Learn to unlock trophies and complete tasks. Everything else is seamless, structured, and to the point.

Here are the complete official steps to complete the certification:

Steps to earn your certificate

1. Go to the Foundational C# Certification path on freeCodeCamp. Here you’ll find the training content under Courses. Press Expand course to find all the modules within each course.

   

2. Click on each module in the course to find the link to the training content for that module.

   

3. Complete the training content on Microsoft Learn. (Note: If you have previously completed the training content, you do not need to redo it)

   

4. Once you are done, complete the comprehension check question on freeCodeCamp.

5. At the end of each course, you will receive a Trophy on Microsoft Learn. Each step on freeCodeCamp will show instructions for how you can claim and submit these Trophies.

6. Once you complete all the training, take the exam.

7. Earn your certification!

I have gone through the course and completed the certification.

Conclusion

Overall this Certification is worth it and is recommended for all.

Have you tried this new C# certification? What are your thoughts on this? Comment below.

After having written more than 1 million lines of code and having read much more awful lot, here are the top 5 things I wish I knew sooner to write more readable code.

#1. Your code will be read more times than you think.

A common misconception among upcoming and new developers is — Software Development is about writing the O(n) complexity code of binary tree inversion. And I hate to break it to you — it’s not.

A lot of time it’s about, adding a new feature or fixing a bug in an existing code base with its own coding conventions, naming conventions, design, and architecture. So reading and understanding the existing code becomes one of the most important parts of the job.

Great developers spend a lot of time reading other people’s code.

#2. Readable code > Smart Code

In almost all programming languages and frameworks, there are numerous ways of doing the same thing. The smarter and one-liner way may feel good to write at the moment, but often it’s not good for the next reader — which can be YOU six months down the line.

So,

If there is a little more verbose but more readable way to do it — do it and your future self will thank you later.

#3. Document the “why” instead of “what”.

Usually, I’m against documentation. Because

The code is literally the instructions written to build something.

The only parts that need documentation are the “why”. Why we’ve written this piece of code this way?

If you don't understand the "what"? Maybe you shouldn't be the one changing it.

#4. Describe everything your function/method does in the name.

There are only 2 difficult things in Computer Science — Cache Invalidation and Naming

Just by reading the name of the function, its intent should be clear.

“But then large functions would have way big names” — that’s the point. Your function should do only 1 or a few things and do it properly.

Refactor the function/method if it’s job can’t be described in the name.

#5. “Deadline” is a silly excuse for writing bad code.

“There’s no time to write good code” is not a good enough excuse for writing bad code.

Checking for the readability of your code is like flushing the toilet — it’s part of the ceremony. You do it no matter how late you are for anything else.

So next time you write code, think about your future self, what would you answer to that person? Don’t bring shame to yourself. Write readable code.

Happy Coding!

You are working on a cool new project, and want to implement the amazing new design pattern that you learned about a few days ago. All is well. Until your boss comes to your desk and tells you the release is preponed (is that even a word?) by 10 days. WTH man! Now whatever plans you had to make the code readable, testable, SOLID - goes for a toss, and you stuff the code to make up for the early release.

So you bought some time by writing "not-so-good code" to meet the deadline.

Let this sink in for a moment.

You know that the code that you had written needs to be refactored, but you don't have the bandwidth (not the internet one) to do so, so you live with this "bad code" - aka technical debt.

Well, debts inherently aren't bad, you take debts all the time - Credit Cards, Car loans, House loans. But you need to pay the interest, and as long you re-pay, it's well and good. The same goes for the technical debt. It's a trade-off between Product Delivery and impeccable code.

How do I know that I have a Technical Debt

Some time ago, I did not have any single tool which can give a clear idea of what kind of and how much technical debt I had.

I was looking at different metrics e.g., Code Duplication, Cyclomatic Complexity, Test Coverage, Dependency and Coupling, and more to get an idea.

Then I stumbled upon NDepend.

NDepende can scan your code base and tell you how much technical debt you have in a single actionable dashboard.

What is NDepend

NDepend can do much more than that, e.g.,

• Code Rule and Code Query over LINQ (CQLinq)

• Powerful Dependency Graph and Matrix

• Smart Technical Debt Estimation

• Quality Gates

• In-Depth Issues Management

• Trend Monitoring

• Harness Test Coverage Data

• Code Quality and Code Metrics

• Detect Dependency Cycles

• Code Diff since Baseline

• Enforce Immutability and Purity

• Complexity and Diagrams

• Continuous Integration Reporting

• Warnings on Build

• Process Health

and more.

They consider themselves, The "Swiss Army Knife" for .NET Developers, Architects and Teams

Visit their official site to know more.

The NDepend team was generous to give me a copy of their license to try out the product

If you're new to NDepend or want to know how to install and get started, folks at NDepend have written wonderful step-by-step documentation.

The thing I like about NDepend is, it gives me a visual dashboard that is actionable. And all the data it provides, has LINQ queries to support that and accommodate custom rules as well.

How to find out Technical Debt

For this post, I've taken the Clean Architecture repo from Jason Taylor. If you don't know Jason, he's the Clean Architecture guy, a great developer, trainer, architect, and more.

Once you clone the repo in Visual Studio, here's what the Project structure looks like:

An Angular SPA with Application Layer, Domain Layer, and Infrastructure Layer - the Clean Architecture.

Attached is the NDepend to this solution:

NDepend will detect the projects and exclude test projects. Click on Analyze X NET Assemblies.

Give it some time to finish.

Click on the View NDepend Dashboard.

Dashboard

The dashboard gives you a plethora of information about the Project code quality, lines of code, issues, and comments, but we're interested in technical debt.

In this case, you can see there is a 5.56% of technical debt. Well done, Jason!

The Smart Technical Debt feature of NDepend also tells us how many days it would take us to resolve the technical debt.

Amazing, right?

Additionally, it gives us the Rating of the project based on Technical Debt. In our case, B. is Pretty good. And how much effort is required to reach A?

Exploring Technical Debt

If you click on the rating, NDepend will show you the hot spots of the code where most of the debt is.

Clicking on the Debt % gives the list of all the issue

Click on a specific rule to find out the details and what all code has contributed to this technical debt.

In the above example, our code base has violated the following rule:

• Rule Name: Avoid namespaces dependency cycles • Rule Id: ND1401 • Rule Explicit Id: AvoidNamespacesDependencyCycles

• Rule Description:

This rule lists all application namespace dependency cycles. Each row shows a different cycle, indexed with one of the namespaces entangled in the cycle.

Read our white books relative to partitioning code, to know more about namespaces dependency cycles, and why avoiding them is a simple yet efficient solution to clean the architecture of a code base. https://www.ndepend.com/docs/white-books

• How to Fix Issues of this Rule:

Removing the first pairs of mutually dependent namespaces will eliminate most namespaces dependency cycles. This is why it is recommended to focus first on matches of the default rule Avoid namespaces mutually dependent before attempting to fix issues of the present rule.

Once all mutually dependent namespace occurrences are solved, remaining cycles matched by the present rule necessarily involve 3 or more namespaces like in: A is using B is using C is using A.

To browse a cycle on the dependency graph or the dependency matrix, right-click a cycle cell in the result of the present rule and export the matched namespaces to the dependency graph or matrix. This is illustrated here: https://www.ndepend.com/docs/visual-studio-dependency-graph#Entangled

With such a cycle graph visualized you can determine which dependencies should be discarded to break the cycle. To do so, you need to identify which namespace should be at low level and which one should be at high-level.

In the A is using B is using C is using A cycle example, if A should be at a low level then C should be at a higher level than A. As a consequence C shouldn't use A and this dependency should be removed. To remove a dependency you can refer to patterns described in the HowToFix section of the rule Avoid namespaces mutually dependent.

Notice that the dependency matrix can also help to visualize and breaking cycles. In the matrix, cycles are represented with red squares and black cells. To easily browse dependency cycles, the dependency matrix comes with an option: Display Direct and Indirect Dependencies. See related documentation here: [https://www.ndepend.com/docs/dependency-structure-matrix-dsm#Cycle https://www.ndepend.com/docs/dependency-structure-matrix-dsm#Mutual](https://www.ndepend.com/docs/dependency-structure-matrix-dsm#Cycle https://www.ndepend.com/docs/dependency-structure-matrix-dsm#Mutual?utm_source=blog.satishyadav.com&utm_medium=technical_debt_blog_post)

The estimated Debt, which means the effort to fix such issue, doesn't depend on the cycle length. First, because fixing the rule Avoid namespaces mutually dependent will fix most cycles reported here, and second because even a long cycle can be broken by removing a single or a few dependencies.

• How to Suppress an Issue of this Rule:

In the source code, tag the concerned code element with this attribute: [SuppressMessage("NDepend", "ND1401:AvoidNamespacesDependencyCycles", Justification="...")] This attribute requires the compilation symbol CODE_ANALYSIS to be set on each Visual Studio project relying on it. Without the CODE_ANALYSIS symbol defined, the attribute is not compiled and the issues are not suppressed.

Pretty detailed, right?

Next steps

Now you have a basic understanding of what Technical Debt is and how NDepend can take you into your journey of becoming Technical-Debt-free (if that's a thing).

Visit the NDepend site to learn more.

Here's the repo used in this post, give this a star:

https://github.com/iSatishYadav/CleanArchitectureCodeBase

Originally posted at:

https://blog.satishyadav.com/managing-technical-debt-with-ndepend

Happy Coding!

If you've installed Windows enough times, you already know the pain of installing all your Software and Apps again and again. If you haven't, let me save you the pain and show you how to:

Automate the installation of Windows Software and Apps

Package Manager FTW!

What we need here is something called Package Manager, which we can give some commands and it would install the software from the command line itself.

Why command line — so that we can repeat the process.

Windows doesn't have an official Package Manager yet, but Chocolatey is your safest bet.

Windows has gotten winget but it's relatively new and community support/references are much better for Chocolatey.

So here's what we're going to do, we need to search and list down all the software that we typically install and save that command at a place where we can refer it later. It can be on any of Drives (Google Drive, OneDrive) or if you're a developer or power user (whatever that is) - on a Git repo. I don't care, as long as you have access to it when the time comes.

So let's get to it.

1. Install Chocolatey itself

From an Admin terminal (PowerShell or Windows Terminal)

Set-ExecutionPolicy Bypass -Scope Process -Force; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

2. Install packages

If you are already familiar with the package names of individual Software or the App, you can skip this otherwise you can search

2.1 Search

Let's say I don't know what is the name of the Node.js package. I can search:

2.1.1 Search from CLI

choco search nodejs

It should return results something like that:

nodejs 16.11.0 [Approved]
nodejs.commandline 6.11.0 [Approved]
nodejs.install 16.11.0 [Approved]
nodejs-lts 14.18.0 [Approved]
...
30 packages found.

Homework: What does [Approved] mean?

2.1.1 Seach from Chocolatey site:

Visit https://community.chocolatey.org/packages to find all the supported packages. You can find all sorts of amazing Software and Apps including day-to-day software like Chrome, Zoom, and iTunes - to Enterprise Developer Tools like Visual Studio, Python, Azure and AWS CLI - and whatnot.

2.2 Install

This is how you install a package. From an Admin terminal:

• Node.js

choco install nodejs-lts

• VS Code

choco install vscode

Now you can save all this in a file and install, but wait "where is the automation you promised? I need my money back." Don't worry, people way smarter than me have thought about this and come up with:

Packages.config

There's an official way to list all the packages and install from that file.

Here's what a typical package looks like:

<?xml version="1.0" encoding="utf-8"?>
<packages>
    <package id="vscode" />
    <package id="nodejs-lts" version="14.18.0" />
</packages>

Save this file and in future you can install all the Software and Apps. e.g.

choco install "sample-packages.config"

Since I already have these packages installed, I got the following message, but you can figure it out from here.

Installing from config file:
sample-packages.config
By installing, you accept licenses for the packages.
Installing the following packages:
vscode
nodejs-lts
vscode v1.61.0 already installed.
 Use --force to reinstall, specify a version to install, or try upgrade.
nodejs-lts v14.18.0 already installed.
 Use --force to reinstall, specify a version to install, or try upgrade.

Chocolatey installed 0/2 packages.
 See the log for details (C:\ProgramData\chocolatey\logs\chocolatey.log).

Conclusion

That's it! This is how you can automate the installation of your favourite Software and Apps in a repeatable way.

If you liked this, please like and share this post. And visit https://github.com/iSatishYadav/AutomateWindowsSoftwareInstallation and give this repo a star.

Originally posted at:

https://blog.satishyadav.com/automate-new-windows-machine-installation

Happy Hacking!

Docker is an open-source platform for building, deploying, and managing containerized applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly.

It is based on the idea that you can package your code with dependencies into a deployable unit called a "container" that has everything the software needs to run including libraries, system tools, code, and runtime.

Wait, but what's a "Container"?

A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another.

Containers are made possible by process isolation and virtualization capabilities built into the Linux kernel. As a result, container technology offers all the functionality and benefits of VMs - including application isolation, cost-effective scalability, and disposability - plus important additional advantages:

• Lighter weight

• Greater resource efficiency

• Improved developer productivity

That's too much jargon, can you give me a simple analogy?

Perhaps a simple analogy can help get a grasp of the core concept of Docker...

Let's go back in time to the 1950s for a moment. There were no word processors, and photocopiers were used everywhere (kind of).

Imagine you're responsible for quickly issuing batches of letters as required, to mail them to customers, using real paper and envelopes, to be delivered physically to each customer's address (there was no email back then).

At some point, you realize the letters are just a composition of a large set of paragraphs, which are picked and arranged as needed, according to the purpose of the letter, so you devise a system to issue letters quickly, expecting to get a hefty raise.

The system is simple:

You begin with a deck of transparent sheets containing one paragraph each.

To issue a set of letters, you pick the sheets with the paragraphs you need, and then you stack and align them so they look and read fine.

Finally, you place the set in the photocopier and press start to produce as many letters as required.

So, simplifying, that's the core idea of Docker.

In Docker, each layer is the resulting set of changes that happen to the filesystem after executing a command, such as installing a program.

So, when you "look" at the filesystem after the layer has been copied, you see all the files, including the layer when the program was installed.

You can think of an image as an auxiliary read-only hard disk ready to be installed in a "computer" where the operating system is already installed.

Similarly, you can think of a container as the "computer" with the image hard disk installed. The container, just like a computer, can be powered on or off.

Why use Docker

Using Docker lets you ship software faster, standardize application operations, seamlessly move code, and save money by improving resource utilization.

With Docker, you get a single object that can reliably run anywhere. Docker's straightforward syntax gives you full control. Wide adoption means there's a robust ecosystem of tools and off-the-shelf applications that are ready to use with Docker.

Docker is so popular today that Docker and container are used interchangeably.

But, we already have Virtual Machines? Why Containers?

Docker tools and terms

Let us familiarize ourselves with Docker terminology.

DockerFile

Every Docker container starts with a simple text file containing instructions for how to build the Docker container image. DockerFile automates the process of Docker image creation. It’s essentially a list of command-line interface (CLI) instructions that Docker Engine will run to assemble the image.

Docker images

Docker images contain executable application source code as well as all the tools, libraries, and dependencies that the application code needs to run as a container. When you run the Docker image, it becomes one instance (or multiple instances) of the container.

Docker containers

Docker containers are the live, running instances of Docker images. While Docker images are read-only files, containers are live, ephemeral, executable content. Users can interact with them, and administrators can adjust their settings and conditions using docker commands.

Docker Hub

Docker Hub is the public repository of Docker images.

Docker daemon

Docker daemon is a service running on your operating system, such as Microsoft Windows or Apple MacOS or iOS. This service creates and manages your Docker images for you using the commands from the client, acting as the control centre of your Docker implementation.

Docker registry

A Docker registry is a scalable open-source storage and distribution system for Docker images. The registry enables you to track image versions in repositories, using tagging for identification. This is accomplished using Git, a version control tool.

When to use Docker

You can use Docker containers as a core building block in creating modern applications and platforms. Docker makes it easy to build and run distributed microservices architecture, deploy your code with standardized continuous integration and delivery pipelines, build highly-scalable data processing systems, and create fully-managed platforms for your developers.

Micro-Services

Build and scale distributed application architectures by taking advantage of standardized code deployments using Docker containers.

Continuous Integration & Delivery

Accelerate application delivery by standardizing environments and removing conflicts between language stacks and versions.

Docker deployment and orchestration

If you're running only a few containers, it's fairly simple to manage your application within Docker Engine, the industry's de facto runtime. But if your deployment comprises thousands of containers and hundreds of services, it's nearly impossible to manage that workflow without the help of these purpose-built tools.

Docker Compose

If you're building an application out of processes in multiple containers that all reside on the same host, you can use Docker Compose to manage the application's architecture. Docker Compose creates a YAML file that specifies which services are included in the application and can deploy and run containers with a single command. Using Docker Compose, you can also define persistent volumes for storage, specify base nodes, and document and configure service dependencies.

Kubernetes

To monitor and manage container lifecycles in more complex environments, you'll need to turn to a container orchestration tool. While Docker includes its own orchestration tool (called Docker Swarm), most developers choose Kubernetes instead.

Kubernetes is an open-source container orchestration platform descended from a project developed for internal use at Google.

Kubernetes schedules and automates tasks integral to the management of container-based architectures, including container deployment, updates, service discovery, storage provisioning, load balancing, health monitoring, and more.

Next steps and Credits

Visit the official Docker website to learn more. All major clouds e.g. Azure, AWS, and Google Cloud have Container offerings, visit their sites for more info. Credits: https://aws.amazon.com/docker/ https://www.ibm.com/cloud/learn/docker https://www.docker.com/ https://docs.microsoft.com/en-us/dotnet/architecture/microservices/container-docker-introduction/docker-defined

In this post, we're going to have a look at top 5 most interesting features.

5. Ledger (Blockchain) Support

SQL Server 2022 introduces new Ledger capabilities for creating Blockchain-like immutable records to ensure data integrity. If somebody modifies the record, it would no longer be valid.

It would be beneficial for scenarios such as internal and external audits.

4. Peer-to-peer replica conflict resolution

In a multi-write scenario - With SQL Server 2022, the last-write rule is being automated. Now, when a conflict is detected, the most recent modification time will be chosen to be persisted on all replicas. This helps keep your multi-write scenarios running smoothly.

Previously this peer-to-peer replica conflict would stall the whole operation until it was addressed.

3. Intelligent Query Processing

The next generation of Intelligent Query Processing (IQP) includes solutions to some of the most common problems we face today, without any code changes required including:

MAXDOP and CE model feedback using the Query store to create a feedback cycle to automatically adapt and resolve problems with common query patterns.

2. Parameter Sensitive Query Plan Caching

SQL Server has a great Query Optimizer, but one of the issues faced by a lot of people is Parameter Sniffing. SQL Server caches the execution plan for a Stored Procedure based on certain parameters (sniffing the parameters). This is usually good but it might not necessarily be efficient with another set of parameters.

SQL Server 2022 introduces Parameter Sensitive Plan Optimization which can cache multiple plans based on parameters - without requiring any code change.

Before revealing my top pick, let's see some honourable Mentions:

• Query Store is now turned on by default.

• Read Replica Support for Query Store - you can now use Query Store for your Read-Only workloads of your AG (Available Group).

• New extensions to the T-SQL language to support data virtualization and backup/restore with S3-compatible storage systems. Furthermore, T-SQL will support new JSON functions and time-series capabilities.

• Azure Synapse Link - Previously, moving data from on-premises databases, like SQL Server, to Synapse required you to use ETL. Azure Synapse Link for SQL Server 2022 provides automatic change feeds that capture the changes within SQL Server and feed those into Azure Synapse Analytics. It provides near real-time analysis and hybrid transactional and analytical processing with minimal impact on operational systems.

• Azure Purview Integration - Azure Purview is a unified data governance and management service. SQL Server 2022 is integrated with Azure Purview for greater data discovery, allowing you to break down data silos. Through this integration you will be able to:

  • Automatically scan your on-premises SQL Server for free to capture metadata.

  • Classify data using built-in and custom classifiers and Microsoft Information Protection sensitivity labels.

  • Set up and control specific access rights to SQL Server.

Now for the last feature:

1. Fully Managed Disaster Recovery in the Cloud

Using SQL Server 2022 and the new link feature for Azure SQL Managed Instance, you now get all the benefits of running a PaaS environment applied to disaster recovery—allowing you to spend less time on setup and management even when compared to an IaaS environment. This works by using a built-in Distributed Availability Group (DAG) to replicate data to a previously deployed Azure SQL Managed Instance as a DR replica site. The instance is ready and waiting for whenever you need it—no lengthy configuration or maintenance is required. You can also use this link feature in read scale-out scenarios to offload heavy requests that might otherwise affect database performance.

Did I miss any other cool feature? Let me know.

Happy Coding! 👨‍💻

As a newbie to AWS, I was unable to find any comprehensive guide on how to setup and use DynamoDB locally. So without further ado, let's start.

Download the DynamoDB Local (Downloadable Version)

There are 3 ways you can download:

1. Standalone jar file

2. Using Docker

3. Using an Apache Maven

I'm using Docker for this tutorial, for instructions on other 2 ways, visit this official AWS site

Please note your application doesn't have to be a containerized application, we're just using DynamoDB database as a container, that's it.

Using Docker

Make sure you have docker up and running. If you've not, follow this official instructions

docker run -p 8000:8000 amazon/dynamodb-local

This will download DynamoDB locally from official Docker image and run. If everything is okay, you'd see output something like this:

Initializing DynamoDB Local with the following configuration:
Port:   8000
InMemory:       true
DbPath: null
SharedDb:       false
shouldDelayTransientStatuses:   false
CorsParams:     *

This would run the fully functional DynamoDB instance at http://localhost:8000.

[Bonus] Verify installation using AWS CLI.

If don't have AWS CLI installed, follow this official guide

Run this command to verify the installation

aws dynamodb list-tables --endpoint-url http://localhost:8000

If you get an error like this:

You must specify a region. You can also configure your region by running "aws configure".

You can run:

aws configure

And you'd be asked to setup follwoing:

AWS Access Key ID:
AWS Secret Access Key :
Default region name [x]:
Default output format [None]:

You can enter any values, as you're only using DynamoDB locally.

That's it!

That's how you can configure AWS DynamoDB on your local machine to develop and test your applications without spending anything.

Happy Coding!

Originally posted at my blog: https://blog.satishyadav.com/how-to-setup-and-use-dynamodb-locally-free

.NET 6 is the upcoming major overhaul for .NET. It unifies entire .NET experience. No more .NET Core, .NET Full Framework, Xamarin, Mono, etc. Just a single .NET.

New LINQ Features

At the time of writing this post, 5 previews of .NET 6 have been released and last couple of releases have been blessing for LINQ.

Here are few top new LINQ features:

• New methods MaxBy and MinBy

• New methods Chunk

• New methods DistinctBy, UnionBy, IntersectBy, and ExceptBy

• Index and Range parameters

• New method TryGetNonEnumeratedCount

• Default parameters for FirstOrDefault, LastOrDefault, and SingleOrDefault

• Zip supports 3 IEnumerables

New methods MaxBy and MinBy

Finding out maximum or minimum has been easier than even with these new MaxBy or MinBy methods.

Suppose a List of Persons as:

static List<Person> people = new List<Person>
{
    new Person { Id = 1, Name = "Amit", Age = 38},
    new Person { Id = 2, Name = "Ravi", Age = 36},
    new Person { Id = 3, Name = "Manish", Age = 34},
    new Person { Id = 4, Name = "Satish", Age = 29},
};

If we need to get maximum and minimum, currently here's how to do it:

//Without using MaxBy and MinBy
Person oldestPerson = people.OrderByDescending(person => person.Age).First();
Person youngestPerson = people.OrderBy(person => person.Age).First();
Console.WriteLine($"Oldest Person without using MaxBy: {oldestPerson.Name}");
Console.WriteLine($"Youngest Person without using MaxBy: {youngestPerson.Name}");

But with MaxBy and MinBy, it's just a single method call:

Person oldestPerson = people.MaxBy(person => person.Age);
Person youngestPerson = people.MinBy(person => person.Age);
Console.WriteLine($"Oldest Person using MaxBy: {oldestPerson.Name}");
Console.WriteLine($"Youngest Person using MaxBy: {youngestPerson.Name}");

Neat, right? Let me know in the comments if you have alternate methods of getting maximum and minimum using LINQ.

New method Chunk

A new method Chunk slices the IEnumerable into provided sizes. e.g. If you have a collection of 4 elements and you need to cluster them into fixed size of 2, here's how to do it:

IEnumerable<Person[]> cluster = people.Chunk(2);
// Print each cluster.
foreach(var people in cluster)
{
    Console.WriteLine($"Cluster of {string.Join(",", people.Select(person => person.Name))}");
}
//Prints
// Cluster of Amit,Ravi
// Cluster of Manish,Satish

New methods DistinctBy, UnionBy, IntersectBy, and ExceptBy

Existing set methods Distinct, Union, Intersect, and Except have been powered up by these new methods which can take a selector function to operate. e.g.

IEnumerable<Person> evenAgedPeople = people.Where(person => person.Age % 2 == 0);
//Amit,Ravi,Manish

IEnumerable<Person> personAbove35 = people.Where(person => person.Age > 35);
//Amit,Ravi

IEnumerable<Person> union = evenAgedPeople.UnionBy(personAbove35, x => x.Age);
//Amit,Ravi,Manish

IEnumerable<Person> intersection = evenAgedPeople.IntersectBy(personAbove35.Select(p => p.Age), x => x.Age);
//Amit,Ravi

Let me know in the comments, the usage of DistinctBy and ExceptBy.

Index and Range parameters

Range: .., and Index: ^ already exist in C#8, .NET 6 brings these two to LINQ.

• The ElementAt operator now takes indices from the end.

Person secondLastPerson = people.ElementAt(^2);
//Manish

• Skip and Take now take Range as well:

IEnumerable<Person> take3People = people.Take(..3);
//Amit,Ravi,Manish

IEnumerable<Person> skip1Person =  people.Take(1..);
//Ravi,Manish,Satish

IEnumerable<Person> take3Skip1People = people.Take(1..3);
//Ravi,Manish

IEnumerable<Person> takeLast2People = people.Take(^2..);
//Manish,Satish

IEnumerable<Person> skipLast3People = people.Take(..^3);
//Amit

IEnumerable<Person> takeLast3SkipLast2 = people.Take(^3..^2);
//Ravi

New method TryGetNonEnumeratedCount

Sometimes you need to get a count without the enumeration. TryGetNonEnumeratedCount will try to get a count without forcing an enumeration. It internally checks for the implementation of ICollection i.e. IEnumerable - that already has a mechanism to get a count without forcing an enumeration. Otherwise, it'll try to take advantage of new improvements in LINQ. Useful in scenarios where you want to get a count but not at the cost of enumerating the IEnumerable. e.g.

List<Person> anotherList = people.TryGetNonEnumeratedCount(out int count) ? new List<Person>(count): new List<Person>();
anotherList.AddRange(people);

In our case right now, we know that people is just an in-memory list, but what if it was from a database of some Stream, then it would've made sense to find out the count to optimize the instantiation of anotherList object by specifying capacity parameter.

Default parameters for FirstOrDefault, LastOrDefault, and SingleOrDefault

Current FirstOrDefault, LastOrDefault, and SingleOrDefault methods return default(T) if the source IEnumerable is empty. The new overloads accept a parameter that will be returned if the source is empty.

e.g.

List<int> emptyList = new List<int>();
int value = emptyList.FirstOrDefault(-1);
//-1 instead of 0

This reminds me of ISNULL function of SQL Server.

Zip supports 3 IEnumerables

Before .NET 6, Zip used to take only 2 parameters. Now it takes 3 parameters:

IEnumerable<int> ids = Enumerable.Range(1, 4);
IEnumerable<Person> allPeople = people;
IEnumerable<int> allAges = people.Select(person => person.Age);

IEnumerable<(int Id, Person Person, int Age)> zipped = ids.Zip(allPeople, allAges);

Conclusion

.NET 6 previews bring an awesome set of new features with every new release. Let me know in the comments which features you're excited about.

Next Steps

• Download .NET 6 today and try it out.

• The source code is available at: https://github.com/iSatishYadav/.net-6-linq-new-features

Originally published at my blog at: https://blog.satishyadav.com/.net-6-linq-new-features

Visual Studio 2022 Preview 1 is now available! If you've missed the official announcement on June 17th, 2021 - check it out. If you want to try out, head over to the official download page here.

The Visual Studio 2022 previews can be installed side-by-side with earlier versions of Visual Studio, are available in all three editions (Community, Pro, and Enterprise), and are free to use.

New Features

A lot of new features have come out in this release, however, Visual Studio 2022 is just out with Preview 1, meaning there will be more and more new features coming in new Previews.

But today I want to talk about 2 of my favorite features:

• 64-bit

• IntelliCode

64-bit

The first and the biggest feature is - and boy, that's big one - it's 64-bit!!! 😍 This means - Visual Studio 2022 will no longer be limited to ~4gb of memory in the main devenv.exe process.

In Microsoft's own words:

With a 64-bit Visual Studio on Windows, you can open, edit, run, and debug even the biggest and most complex solutions without running out of memory.

This doesn't mean you can't develop 32-bit applications using Visual Studio 2022, it just means the Visual Studio itself wil be able to fully utilize your 64-bit hardware.

IntelliCode - one step further

This one's my favorite new feature. We all know and love IntelliCode - Microsoft's AI-enabled Visual Studio component which suggests code changes using Machine Learning Model based on 1000s of Open-Source GitHub repositories and optionally your own repositories if you permit.

In Visual Studio 2022, IntelliCode has gone one step further and not only will suggest the code changes, but it'll also will write the code for you 😲. Look at this GIF:

• As soon as I write StringBuilder, it knows what I'm about to write and with the TAB press, it writes StringBuilder sb = new StringBuilder(); for me.

• Similarly in the foreach loop, it know I'm going to append the item to the StringBuilder and writes sb.Append(item) for me.

• Finally after the loop it knows I want to print it, so it prints using Console.WriteLine by calling ToString() on the StringBuilder reference sb.

Cool, right!!!

Conclusion

This is just a Preview 1, there will be at-lest 4-5 previews before it hits GA - General Availability. So watch out for more posts.

Let me know which features ya'll are excited about.

Next Steps

• Read more about IntelliCode.

• Check out the Official announcement

• Download Visual Studio 2022 and try it now.

Originally Posted at: https://blog.satishyadav.com/Visual-Studio-2022-will-write-code-for-you/

Happy Coding! 👨‍💻