Hubbry Logo
List of .NET libraries and frameworksList of .NET libraries and frameworksMain
Open search
List of .NET libraries and frameworks
Community hub
List of .NET libraries and frameworks
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
List of .NET libraries and frameworks
List of .NET libraries and frameworks
List of .NET libraries and frameworks
View on Wikipedia
from Wikipedia

This article contains a list of libraries that can be used in .NET languages. These languages require .NET Framework, Mono, or .NET, which provide a basis for software development, platform independence, language interoperability and extensive framework libraries. Standard Libraries (including the Base Class Library) are not included in this article.

Introduction

[edit]

Apps created with .NET Framework or .NET run in a software environment known as the Common Language Runtime (CLR),[1] an application virtual machine that provides services such as security, memory management, and exception handling. The framework includes a large class library called Framework Class Library (FCL).

Thanks to the hosting virtual machine, different languages that are compliant with the .NET Common Language Infrastructure (CLI) can operate on the same kind of data structures. These languages can therefore use the FCL and other .NET libraries that are also written in one of the CLI compliant languages. When the source code of such languages are compiled, the compiler generates platform-independent code in the Common Intermediate Language (CIL, also referred to as bytecode), which is stored in CLI assemblies. When a .NET app runs, the just-in-time compiler (JIT) turns the CIL code into platform-specific machine code. To improve performance, .NET Framework also comes with the Native Image Generator (NGEN), which performs ahead-of-time compilation to machine code.

This architecture provides language interoperability. Each language can use code written in other languages. Calls from one language to another are exactly the same as would be within a single programming language. If a library is written in one CLI language, it can be used in other CLI languages. Moreover, apps that consist only of pure .NET assemblies, can be transferred to any platform that contains an implementation of CLI and run on that platform. For example, apps written using .NET can run on Windows, macOS, and various versions of Linux.

.NET apps or their libraries, however, may depend on native platform features, e.g. COM. As such, platform independence of .NET apps depends on the ability to transfer necessary native libraries to target platforms. In 2019, the Windows Forms and Windows Presentation Foundation portions of .NET Framework were made open source.[2]

.NET implementations

[edit]

".NET Standard" redirects here. For open specification (technical standard) behind .NET standardized by ISO and ECMA, see ECMA 335.

There are four primary .NET implementations that are actively developed and maintained:

  • .NET Framework: The original .NET implementation that has existed since 2002. While not yet discontinued, Microsoft does not plan on releasing its next major version, 5.0.[3]
  • Mono: A cross-platform implementation of .NET Framework by Ximian, introduced in 2004. It is free and open-source. It is now developed by Xamarin, a subsidiary of Microsoft.
  • Universal Windows Platform (UWP): An implementation of .NET used for building UWP apps. It's designed to unify development for different targeted types of devices, including PCs, tablets, phablets, phones, and the Xbox.
  • .NET: A cross-platform re-implementation of .NET Framework, introduced in 2016 and initially called .NET Core. It is free and open-source. .NET superseded .NET Framework with the release of .NET 5.[4]

Each implementation of .NET includes the following components:

The .NET Standard is a set of common APIs that are implemented in the Base Class Library of any .NET implementation. The class library of each implementation must implement the .NET Standard, but may also implement additional APIs. Traditionally, .NET apps targeted a certain version of a .NET implementation, e.g. .NET Framework 4.6.[5][6] Starting with the .NET Standard, an app can target a version of the .NET Standard and then it could be used (without recompiling) by any implementation that supports that level of the standard. This enables portability across different .NET implementations.

The following table lists the .NET implementations that adhere to the .NET Standard and the version number at which each implementation became compliant with a given version of .NET Standard. For example, according to this table, .NET Core 3.0 was the first version of .NET Core that adhered to .NET Standard 2.1. This means that any version of .NET Core bigger than 3.0 (e.g. .NET Core 3.1) also adheres to .NET Standard 2.1.

Implementation Versions of the .NET Standard[7][8][9]
1.0 1.1 1.2 1.3 1.4 1.5 1.6 2.0 2.1
.NET 1.0 2.0 3.0
.NET Framework 4.5 4.5 4.5.1 4.6 4.6.1 4.7.2[a] 4.7.2[a] 4.7.2[a] —[b]
Mono 4.6 5.4 6.2
Xamarin.iOS 10.0 10.14 12.12
Xamarin.Mac 3.0 3.8 5.12
Xamarin.Android 7.0 8.0 9.3
Universal Windows Platform 8[c] 8[c] 8.1[c] 10 10 10 v1709 —[d]
Unity 2018.1 2021.2
Windows Phone 8.1[c] —
Windows Phone, via Silverlight 8[c] —

Web frameworks

[edit]

ASP.NET

[edit]

First released in 2002, ASP.NET is an open-source server-side web application framework designed for web development to produce dynamic web pages. It is the successor to Microsoft's Active Server Pages (ASP) technology, built on the Common Language Runtime (CLR).

ASP.NET Core

[edit]

ASP.NET was completely rewritten in 2016 as a modular web framework, together with other frameworks like Entity Framework. The re-written framework uses the new open-source .NET Compiler Platform (also known by its codename "Roslyn") and is cross platform. The programming models ASP.NET MVC, ASP.NET Web API, and ASP.NET Web Pages (a model using only Razor pages) were merged into a unified MVC 6.[10]

Blazor

[edit]

Blazor is a free and open-source web framework that enables developers to create Single-page Web apps using C# and HTML in ASP.NET Razor pages ("components"). Blazor is part of the ASP.NET Core framework. Blazor Server apps are hosted on a web server, while Blazor WebAssembly apps are downloaded to the client's web browser before running. In addition, a Blazor Hybrid framework is available with server-based and client-based application components.

Numerical libraries

[edit]
Main article: List of Numerical Libraries for .NET

Open-source numerical libraries

[edit]

AForge.NET

[edit]

This is a computer vision and artificial intelligence library. It implements a number of genetic, fuzzy logic and machine learning algorithms with several architectures of artificial neural networks with corresponding training algorithms.

ALGLIB

[edit]

This is a cross-platform open source numerical analysis and data processing library. It consists of algorithm collections written in different programming languages (C++, C#, FreePascal, Delphi, VBA) and has dual licensing – commercial and GPL.

Math.NET Numerics

[edit]

This library aims to provide methods and algorithms for numerical computations in science, engineering and everyday use. Covered topics include special functions, linear algebra, probability models, random numbers, interpolation, integral transforms and more. MIT/X11 license.[11]

Meta.Numerics

[edit]

This is a library for advanced scientific computation in the .NET Framework.

ML.NET

[edit]

This is a free software machine learning library. The preview release of ML.NET included transforms for feature engineering like n-gram creation, and learners to handle binary classification, multi-class classification, and regression tasks. Additional ML tasks like anomaly detection and recommendation systems have since been added, and other approaches like deep learning will be included in future versions.

Proprietary numerical libraries

[edit]

ILNumerics.Net

[edit]

This is a high performance, typesafe numerical array set of classes and functions for general math, FFT and linear algebra. The library, developed for .NET/Mono, aims to provide 32- and 64-bit script-like syntax in C#, 2D & 3D plot controls, and efficient memory management. It is released under GPLv3 or commercial license.[11]

Measurement Studio

[edit]

This is a integrated suite of UI controls and class libraries for use in developing test and measurement applications. The analysis class libraries provide various digital signal processing, signal filtering, signal generation, peak detection, and other general mathematical functionality.

NMath

[edit]

This is a numerical component library for the .NET platform developed by CenterSpace Software. It includes signal processing (FFT) classes, a linear algebra (LAPACK & BLAS) framework, and a statistics package.[11]

3D graphics

[edit]

Open-source 3D graphics

[edit]

Open Toolkit (OpenTK)

[edit]

This is a low-level C# binding for OpenGL, OpenGL ES and OpenAL. It runs on Windows, Linux, Mac OS X, BSD, Android and iOS. It can be used standalone or integrated into a GUI.

Windows Presentation Foundation (WPF)

[edit]

This is a graphical subsystem for rendering user interfaces, developed by Microsoft. It also contains a 3D rendering engine. In addition, interactive 2D content can be overlaid on 3D surfaces natively.[12][13] It only runs on Windows operating systems.

Proprietary 3D graphics

[edit]

Unity

[edit]

This is a cross-platform game engine developed by Unity Technologies[14] and used to develop video games for PC, consoles, mobile devices and websites.

Image processing

[edit]

AForge.NET

[edit]

This is a computer vision and artificial intelligence library.[15][16] It implements a number of image processing algorithms and filters. It is released under the LGPLv3 and partly GPLv3 license. Majority of the library is written in C# and thus cross-platform.[citation needed] Functionality of AForge.NET has been extended by the Accord.NET library.[17][18]

Accord.NET

[edit]

This is another computer vision and artificial intelligence library, available under the Gnu Lesser General Public License, version 2.1. It is mainly written in C#.

Graphical user interface

[edit]

Gtk#

[edit]

These are C# wrappers around the underlying GTK+ and GNOME libraries, written in C and available on Linux, MacOS and Windows.[19]

Windows Forms (WinForms)

[edit]

This is a Microsoft GUI framework. The original Microsoft implementation runs on Windows operating systems and provides access to Windows User Interface Common Controls by wrapping the Windows API in managed code.[20] The alternative Mono implementation is open source and cross-platform (it runs on Windows, Linux, Unix and OS X). It is mainly compatible with the original implementation but not completely. The library is written in C# in order to avoid Windows dependence.[21] At the Microsoft Connect event on December 4, 2018, Microsoft announced releasing of Windows Forms as open source project on GitHub.[22] It is released under the MIT License. Windows Forms has become available for projects targeting the .NET framework. However, the framework is still available only on Windows platform and the Mono incomplete implementation of WinForms remains the only cross-platform implementation.[23][24]

Windows Presentation Foundation (WPF)

[edit]

This is a graphical subsystem for rendering user interfaces in Windows-based applications by Microsoft. It is based on DirectX and employs XAML, an XML-based language, to define and link various interface elements.[25] WPF applications can be deployed as standalone desktop programs or hosted as an embedded object in a website.[citation needed] At the Microsoft Connect event on December 4, 2018, Microsoft announced releasing of WPF as open source project on GitHub.[22] It is released under the MIT License. Windows Presentation Foundation has become available for projects targeting the .NET framework. However, the system is still available only on Windows platform.[23][24]

Windows UI Library (WinUI)

[edit]

This is a set of Microsoft UI controls and features for the Universal Windows Platform (UWP). At the Microsoft Connect event on December 4, 2018, Microsoft announced releasing of WinUI as open source project on GitHub.[22] WinUI has become available for projects targeting the .NET framework. It is released under the MIT License. However, the library is still available only on Windows platform.[23][24]

Xamarin.Forms

[edit]

This is a cross-platform UI toolkit for development of native user interfaces that can be run on macOS, iOS, Android, and Universal Windows Platform apps.[26][27][19]

.NET Multi-platform App UI (.NET MAUI)

[edit]

This is a cross-platform UI toolkit announced in May 2020 that originated as a fork of Xamarin.Forms and that can run on Android, iOS, Linux, macOS, Tizen, and Windows. .NET MAUI will run on .NET 6 and later.[28][29][30] The source code is licensed under MIT License and available on GitHub.[29]

Avalonia

[edit]

This is an open-source cross-platform UI toolkit for development of user interfaces that can be run on Windows, Linux, macOS, iOS, Android, and WebAssembly. The source code is licensed under MIT License and available on GitHub[31]

Quality assurance

[edit]

NUnit

[edit]

This is an open source unit testing framework for .NET, written in C# and thus cross-platform. It is one of many programs in the xUnit family. Licensed under MIT License.

Object–relational mapping

[edit]

.NET Framework natively provides utilities for object–relational mapping[32] through ADO.NET, a part of the .NET stack since version 1.0. In the earlier years of .NET development, a number of third-party object–relational libraries emerged in order to fill some perceived gaps in the framework.[33][34][35] As the framework evolved, additional object–relational tools were added, such as the Entity Framework and LINQ to SQL, both introduced in .NET Framework 3.5. These tools reduced the significance and popularity of third-party object–relational libraries.

Entity Framework

[edit]

This is an open source[36] object–relational mapping (ORM) framework for ADO.NET. It was a part of .NET Framework, but since Entity framework version 6 it is separated from .NET framework.

NHibernate

[edit]

NHibernate is an object–relational mapper for the .NET platform.

Notes

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

List of .NET libraries and frameworks

View on Grokipedia
from Grokipedia
The list of .NET libraries and frameworks compiles an extensive catalog of software components designed to enhance the .NET platform, Microsoft's free, open-source, and cross-platform developer framework for building modern applications across web, mobile, desktop, , and other domains. This ecosystem primarily revolves around , the official package manager for .NET, which serves as the central repository hosting over 390,000 unique packages that developers can discover, install, and manage to accelerate . These libraries and frameworks range from core runtime extensions to specialized tools, supporting languages like C#, F#, and while ensuring compatibility across Windows, macOS, , , and Android. Key official frameworks within the .NET ecosystem include , a high-performance, cross-platform framework for developing web applications and services that integrates seamlessly with modern client-side technologies such as Angular, React, and . Another prominent example is .NET MAUI (Multi-platform App UI), which enables developers to create native mobile and desktop applications from a single shared codebase, targeting platforms like Windows, macOS, , and Android. For data access, Entity Framework Core provides a lightweight, extensible object-relational mapper (ORM) that simplifies interactions with relational databases using domain-specific .NET objects, supporting cross-platform deployment. Beyond these Microsoft-maintained components, the list encompasses a vast array of third-party open-source libraries addressing diverse needs, such as with ML.NET, a framework for building custom models integrated directly into .NET applications. The ecosystem's breadth fosters innovation, with packages available for testing (e.g., or ), logging (e.g., Serilog), , and more, all contributing to .NET's reputation for productivity and scalability in enterprise and cloud-native development. This compilation highlights the platform's evolution from its origins in .NET Framework to the unified .NET 10 release, emphasizing performance improvements and AI integration capabilities.

Introduction

Overview of the .NET Ecosystem

.NET is a free and open-source developer platform built by for creating a wide range of applications, including web, mobile, desktop, and cloud-native solutions. It provides developers with tools, programming languages like C#, and libraries to build secure, reliable, and high-performance software that runs across multiple operating systems. The platform emphasizes productivity through modern features such as automatic and , enabling efficient development for diverse scenarios from console apps to . The .NET ecosystem originated with the .NET Framework in 2002, a Windows-specific platform that introduced managed code execution and a rich class library for building applications. In 2016, Microsoft released .NET Core 1.0, an open-source, modular, and cross-platform evolution designed for server and cloud workloads, addressing limitations of the original framework. The unification of these branches began with .NET 5 in November 2020, merging APIs, tools, and runtimes into a single platform to simplify development across mobile, desktop, and web. Subsequent annual releases have continued this trajectory, including .NET 6 (November 2021), .NET 7 (November 2022), .NET 8 (November 2023), .NET 9 (November 2024), and .NET 10 (November 2025), the latest Long-Term Support (LTS) release featuring enhanced AI integration, runtime performance boosts, and developer productivity improvements. At its core, .NET relies on the (CLR), which manages code execution, provides garbage collection for , and ensures and . Complementing the CLR is the Base Class Library (BCL), a comprehensive set of reusable types and APIs for tasks like file I/O, networking, and data structures, forming the foundation for application development. Libraries and frameworks are distributed and managed via , the official , which hosts hundreds of thousands of packages to extend .NET functionality. .NET libraries come in various forms, including class libraries that provide reusable code components—such as portable class libraries compatible with multiple platforms or platform-specific ones tied to environments like Windows—and higher-level frameworks that offer abstractions for specific domains, like . These components integrate through assemblies, which are deployable units containing compiled code, and are organized into namespaces for logical grouping and to avoid naming conflicts. The platform's benefits include robust cross-platform support for Windows, , and macOS, enabling a single codebase across environments, alongside significant performance enhancements in recent versions, such as optimized runtime execution and reduced usage. This expansive ecosystem, bolstered by over 300,000 packages, fosters rapid innovation and community contributions.

.NET Implementations and Runtimes

The .NET ecosystem encompasses several runtime implementations that execute .NET code, each designed for specific platforms and use cases. These runtimes provide the (CLR) environment, including just-in-time () compilation, garbage collection, and , enabling developers to build applications with managed code. Key implementations include the legacy .NET Framework, the modern cross-platform .NET, and open-source alternatives like Mono, which have evolved to support diverse deployment scenarios from desktop to mobile and embedded systems. The .NET Framework is a Windows-only runtime that serves as the foundational implementation for many enterprise applications. It includes the full (CLR) and a comprehensive class library, supporting versions from 1.0 (2002) up to 4.8.1, which was released in August 2022 as the final major update. This runtime excels in legacy Windows desktop and server environments, powering applications with integrated access and features like and Windows Presentation Foundation. Its role in enterprise settings remains significant due to backward compatibility and extensive tooling support, though it lacks cross-platform capabilities. In contrast, .NET (previously known as .NET Core) is a free, open-source, cross-platform runtime that unifies development across Windows, macOS, , Android, iOS, and more. Built on the lightweight CoreCLR, it introduces a modular architecture allowing developers to include only necessary components for smaller deployments. Starting with .NET 5 in 2020, it represents a unified platform merging .NET Framework and .NET Core APIs, with ongoing support through long-term support (LTS) releases like .NET 8 (2023). A key advancement is ahead-of-time (AOT) compilation, introduced in .NET 7 (2022), which compiles code to native binaries at build time for faster startup and reduced memory usage, particularly beneficial for cloud-native and mobile apps. Mono provides an open-source .NET implementation primarily for non-Windows platforms, originating in to enable .NET development on and other systems. It uses its own CLR variant and has been instrumental in projects like for mobile development and Unity for game engines. The latest stable Mono release, 6.12.0, arrived in February 2021, but integrated Mono's runtime components into the main .NET project starting with .NET 6 (2021), enhancing cross-platform support for and Android without a separate Mono distribution. This integration allows Mono-compatible code to run seamlessly on the unified .NET runtime. For .NET MAUI (Multi-platform App UI), the runtime leverages the cross-platform .NET CoreCLR with specific extensions for native UI rendering. It supports Blazor Hybrid, where Blazor components render natively using platform-specific WebViews (e.g., WKWebView on , WebView2 on Windows), combining web technologies with native performance across desktop and mobile platforms. This approach enables single-project development for multiple targets while maintaining runtime compatibility with standard .NET libraries. Compatibility across these runtimes is facilitated by .NET Standard, a set of APIs defining portable library contracts. Versions range from 1.0 (2016) to 2.1 (2019), allowing libraries to target multiple runtimes without modification; for instance, .NET Standard 2.0 is supported by .NET Framework 4.6.1+ and .NET Core 2.0+. Deployment optimizations include trimming, which removes unused code to reduce app size, and ready-to-run (RTR) compilation, pre-JITing assemblies for quicker startup, both prominent in .NET since version 3.0 (2019). Performance in .NET runtimes relies on JIT compilation, which dynamically translates intermediate language (IL) to native code at runtime, and a generational garbage collector that manages memory in three generations (0 for short-lived objects, 1 and 2 for longer-lived ones) to minimize pauses. The RyuJIT optimizer, introduced in .NET Core 2.0 (2017), enhances this with improved instruction selection and loop optimizations, yielding up to 20-30% better throughput in benchmarks compared to prior versions, particularly for server workloads. These features underscore the runtimes' efficiency in handling high-scale applications.

Web Development Frameworks

ASP.NET Core

ASP.NET Core is a modular, open-source, cross-platform developed by for building modern, cloud-based web applications and APIs using the .NET platform. It supports development on Windows, , and macOS, enabling high-performance server-side rendering of dynamic web pages and services. The framework emphasizes modularity, allowing developers to include only necessary components to minimize overhead, and it integrates seamlessly with the .NET ecosystem for full-stack development. The framework evolved from the traditional , which was Windows-specific and separated into MVC for web apps and for services; unified these into a single, lightweight model starting with .NET 5 in 2020, redesigning for cross-platform compatibility and performance. This unification eliminated legacy dependencies, introducing a streamlined architecture that supports both MVC patterns and page-based models via . In .NET 6 (released November 2021), minimal APIs were added to simplify HTTP endpoint creation with minimal boilerplate, ideal for and lightweight APIs using just a few lines of code like app.MapGet("/", () => "Hello World");. The .NET 10 release (November 2025) further refines minimal APIs with improved validation, OpenAPI enhancements, and better cloud-native optimizations. Core features include the middleware pipeline, a sequence of delegating handlers that process HTTP requests and responses in a configurable order, enabling custom request handling such as or . serves as the default cross-platform , supporting high-concurrency workloads with HTTP/1.1, , and WebSockets, and it operates in in-process hosting (within the app process for optimal performance) or out-of-process mode (e.g., behind IIS for additional features). provides a syntax for embedding C# in to generate dynamic views and pages, while the built-in (DI) container manages service lifetimes (singleton, scoped, transient) and resolves dependencies automatically. Key components encompass endpoint routing, which matches URLs to handlers using templates and constraints (e.g., {id:int} for parameters), and Identity, a membership system for user , authorization, roles, and external provider integration like . Performance benchmarks demonstrate ASP.NET Core's efficiency, consistently ranking among the top frameworks in TechEmpower Web Framework Benchmarks, with serialization throughput reaching approximately 742,000 requests per second in Round 23 (February 2025). It supports integration with for high-performance RPC services, where endpoints leverage ASP.NET Core's DI and logging for streamlined microservice communication. enables real-time features like live updates, integrating directly into the middleware pipeline for bidirectional client-server messaging. For deployment, apps can be published as self-contained executables including the runtime for platform independence or framework-dependent to reduce size, with native Docker support via dotnet publish /t:PublishContainer for containerized environments. Azure integration allows seamless hosting on App Service, where apps deploy via or CLI, configuring settings through the portal for scalable, managed execution.

Blazor

Blazor is a free and open-source developed by for building interactive client-side web user interfaces using C# and .NET, rather than . It leverages syntax to combine markup with C# code in reusable components, enabling developers to create rich, dynamic applications that run either server-side or client-side in the browser. Blazor supports a unified development model across different hosting environments, allowing for seamless integration of server-side rendering with client interactivity. Blazor operates through three primary hosting models. In Blazor Server, components execute on the server, with user interface events and updates transmitted to the client via a connection for real-time synchronization, resulting in low-latency interactions without requiring a download of the .NET runtime. runs the full .NET runtime directly in the browser using , enabling client-side execution of C# code for offline-capable applications, though it involves an initial download of the runtime. Blazor Hybrid extends this to native desktop and mobile applications, such as those built with .NET MAUI, by embedding components in a web view for cross-platform UI development. Blazor components are defined in .razor files using syntax, which blends with C# directives for declarative UI construction, such as @onclick for event handling and parameter binding for data flow between components. is handled through built-in mechanisms like component parameters, cascading values for propagating data down the component tree, and services for shared application state; third-party libraries like Fluxor can implement more advanced patterns such as for predictable state updates. These components render efficiently via a lightweight DOM diffing that minimizes updates to the browser's DOM. Introduced experimentally in 2018, Blazor entered official preview in 2019 and achieved full release with in .NET 5 in 2020, marking its maturity as a production-ready framework. The .NET 8 release in 2023 introduced static server-side rendering for faster initial page loads and ahead-of-time (AOT) compilation for to enhance runtime performance by reducing overhead. The .NET 10 release in November 2025 brings further enhancements, including improved hybrid rendering modes, better form handling, and optimized interactive server rendering with compression. Performance optimizations in focus on minimizing payload sizes and execution times; for instance, WebAssembly apps can achieve gzipped bundle sizes under 2 MB for minimal configurations through techniques like runtime relinking, assembly trimming, and compression. Rendering speeds in are competitive with JavaScript frameworks like React, particularly after initial load, due to its virtual DOM-like diffing, though JavaScript frameworks may have advantages in startup time. Common use cases include single-page applications (SPAs) for responsive web experiences and progressive web apps (PWAs) that support offline functionality and installable behaviors via service workers.

SignalR

SignalR is an open-source library for the .NET ecosystem that enables functionality in applications by facilitating bidirectional communication between server and client over HTTP. It abstracts the complexities of transport protocols, allowing developers to build features like live updates without managing low-level connections. Originally developed for the .NET Framework around 2011, SignalR evolved to support cross-platform deployment starting with .NET Core 2.1 in 2018, extending its reach to and macOS environments while maintaining compatibility with and clients for web and mobile applications. This evolution has made it a versatile tool for modern, scalable real-time systems. In .NET 10 (November 2025), SignalR gains improvements like enhanced compression for better performance in Server scenarios. At its core, relies on hubs to enable remote procedure calls (RPCs) for bidirectional messaging, where clients invoke server methods and servers push updates to clients. It establishes persistent connections that automatically negotiate the best available transport, falling back from WebSockets (for full-duplex communication) to or Long Polling if needed to ensure compatibility across browsers and networks. Key features include support for groups, which allow broadcasting messages to subsets of connected clients, and user identification, enabling targeted notifications based on user context rather than individual connections. Streaming capabilities, introduced in .NET 5, further extend this by supporting upload and download streams for efficient handling of large or continuous data flows, such as video feeds or real-time analytics. SignalR integrates seamlessly with , leveraging its middleware pipeline for enhanced scalability through a Redis backplane in clustered environments, which distributes messages across multiple server instances to handle up to 1 million concurrent connections. Common use cases include live chat applications for , push notifications for alerts, interactive dashboards for monitoring system metrics, and gaming lobbies for multiplayer coordination. For security, it supports authentication via JWT bearer tokens for API-like scenarios or cookies for browser-based flows, ensuring only authorized users access hubs. Additionally, message serialization can use for compact, binary encoding to reduce bandwidth and improve performance over . In Blazor Server apps, SignalR powers the underlying transport for real-time UI updates from the server.

User Interface Frameworks

Windows Forms

Windows Forms is an event-driven graphical user interface (GUI) framework designed for developing Windows desktop applications within the .NET ecosystem. It enables developers to create rich, interactive user interfaces using a visual drag-and-drop designer integrated into , where controls such as buttons, text boxes, and menus can be placed on forms to build responsive applications. The framework's architecture relies on the System.Windows.Forms namespace, where all controls inherit from base classes like Control, facilitating event handling and user interactions through a message loop that processes Windows messages. Rendering is handled via GDI+ for 2D graphics, ensuring compatibility with the Windows operating system's native drawing capabilities. Introduced with the .NET Framework 1.0 in February 2002, has evolved alongside the .NET platform, maintaining while receiving updates for modern development needs, including async form support, dark mode, and modern icon APIs in .NET 9 (November 2024). It continues to be supported in .NET 6 and later versions through compatibility layers, allowing existing applications to run on the unified .NET runtime, though positions it primarily for maintaining legacy systems rather than new greenfield projects. Key features include robust data binding, which connects UI controls to data sources like databases or collections for automatic synchronization; support for Multiple Document Interface (MDI) applications, enabling child windows within a parent form for complex layouts; and built-in accessibility compliance via integration with UI Automation (UIA), which exposes UI elements to assistive technologies for users with disabilities. In terms of performance, Windows Forms leverages native Win32 interop for its controls, providing efficient rendering and responsiveness on Windows platforms by directly interfacing with the operating system's APIs. However, it faced limitations in high-DPI scaling prior to .NET Framework 4.7, where applications might appear blurry or improperly scaled on high-resolution displays without explicit DPI awareness configuration; enhancements in .NET 4.7 and later introduced automatic per-monitor DPI support and new events for dynamic scaling changes. Common use cases encompass simple business applications, such as inventory tools or data entry forms, and facilitating migrations from older technologies like Visual Basic 6 (VB6), where its familiar control model eases porting efforts. Despite these strengths, Windows Forms is inherently Windows-only, lacking native cross-platform support without third-party wrappers, which restricts its deployment to non-Windows environments. For applications requiring more advanced features, transitions to frameworks like Windows Presentation Foundation (WPF) offer paths for modernization.

Windows Presentation Foundation

Windows Presentation Foundation (WPF) is a graphical subsystem within the .NET ecosystem designed for creating vector-based desktop applications on Windows, emphasizing rich, interactive user interfaces through declarative markup and hardware-accelerated rendering. At its core, WPF utilizes for defining UI layouts and behaviors declaratively, separating design from code to enable designer-developer workflows. The framework organizes UI elements via logical trees, which represent the hierarchical structure of controls, and resource trees, which manage shared assets like styles and brushes for efficient reuse across the application. Its rendering pipeline leverages for GPU-accelerated composition, processing visual elements into a that is transformed and rasterized for display, with fallback to software rendering when hardware is unavailable. WPF was initially released in November 2006 as part of .NET Framework 3.0, marking a shift toward modern UI development with support for resolution-independent graphics and multimedia integration. Subsequent enhancements in .NET Framework 4.0 (2010) introduced touch input support, enabling gestures for tablet interactions, while later versions like .NET Framework 4.5 (2012) improved performance for high-DPI scenarios and layout virtualization. In 2018, WPF was open-sourced under the and ported to .NET Core, with full compatibility maintained in .NET 6 and later via the Windows Desktop runtime pack, including theming with light and dark mode support in .NET 9 (November 2024), allowing continued development on modern .NET versions without legacy dependencies. Key features of WPF include data templates for binding UI to dynamic data sources, enabling flexible presentation of collections without hardcoding layouts; storyboard-based animations for smooth transitions and effects using timelines and keyframes; built-in 3D graphics support for rendering geometric models with lighting and transformations; and styling mechanisms with themes that apply consistent visual properties across controls, akin to CSS for desktop UIs. WPF achieves high performance through hardware acceleration via 9 and later, offloading , , and effects to the GPU, which supports smooth rendering even for complex scenes. WPF integrates seamlessly with Windows Ink APIs for capturing and processing handwriting input via controls like InkCanvas, supporting real-time recognition and manipulation of strokes. It also facilitates hybrid development with .NET MAUI, where WPF controls can be embedded in cross-platform apps through hosting mechanisms, bridging desktop-specific richness with multi-platform deployment. Common use cases for WPF include enterprise line-of-business (LOB) applications, such as CRM systems and data dashboards that require customizable, data-driven interfaces; media players leveraging its and 3D capabilities for immersive playback; and custom control libraries for specialized industries like or healthcare, where precise vector rendering ensures scalability across display resolutions. For advanced 3D scenarios, WPF supports high-level extensions through interop with libraries like OpenTK.

.NET Multi-platform App UI

.NET Multi-platform App UI (.NET MAUI) is a cross-platform framework from for building native applications across mobile and desktop platforms using C# and XAML, abstracting platform-specific APIs into a unified interface. It enables developers to target Android, , macOS, Windows from a single codebase, leveraging the .NET runtime for shared logic and UI elements. As the evolution of Xamarin.Forms, which provided cross-platform mobile development from 2014 until its end of support in May 2024, .NET MAUI was first released with .NET 6 in November 2021 and has seen significant enhancements, including the .NET MAUI Community Toolkit, improved Hybrid support in .NET 8 (November 2023), and performant handlers for CollectionView and CarouselView on and Mac Catalyst, along with new Hybrid templates in .NET 9 (November 2024). The architecture of .NET MAUI centers on a single project structure that simplifies development by consolidating shared code, resources, and configurations into one location, while allowing platform-specific customizations through conditional compilation and folders. Platform-specific rendering is handled via customizable handlers that map .NET controls to native UI elements, such as UIKit on and macOS (via Mac Catalyst), WinUI 3 on Windows, and Android views on Android. Key features include XAML for declarative UI design, support for Model-View-ViewModel (MVVM) patterns to separate concerns, and Shell for streamlined navigation with built-in and tabs. It provides cross-platform APIs for device features like sensors, networking, and graphics, enabling consistent behavior across targets. Performance in .NET MAUI benefits from native compilation options, including Ahead-of-Time (AOT) compilation for and macOS to produce optimized binaries without JIT overhead, resulting in compact app sizes for minimal applications. Development tooling includes .NET Hot Reload for real-time XAML and C# edits without full rebuilds, Fast Deployment for accelerated initial app deployment particularly on Android, which operates compatibly with Hot Reload to enhance development cycles—Hot Reload requires an active debug session but is unaffected by the initial deployment method—the MAUI workload installable via the .NET SDK for command-line support, and integrated extensions in for project templates, debugging, and deployment. Common use cases encompass enterprise mobile applications requiring device integration, cross-platform desktop hybrids for productivity tools, and scenarios blending native controls with web content via integration in web views.

Data Access and ORM Frameworks

Entity Framework

Entity Framework (EF) is an object-relational mapper (ORM) that enables .NET developers to interact with relational databases using domain-specific objects, abstracting away much of the low-level SQL code. It facilitates the creation of data access layers by mapping .NET classes to database tables and allowing queries via , which translates to SQL under the hood. EF supports both synchronous and asynchronous operations, making it suitable for modern .NET applications ranging from web services to desktop software. EF exists in two primary variants: EF6, a legacy version designed specifically for the .NET Framework, and EF Core, a lightweight, extensible, open-source, and cross-platform iteration that targets .NET Standard 2.0 and later. EF6 remains stable for applications tied to the full .NET Framework but lacks ongoing development for new features. In contrast, EF Core is actively maintained, supports .NET 6 and higher, and runs on Windows, , and macOS, enabling broader deployment scenarios like containerized environments. Core features of EF include LINQ-based querying for type-safe , automated migrations to evolve database schemas from code changes, change tracking to detect and persist entity modifications, and support for both code-first (defining models in code to generate the database) and database-first ( models from an existing database) approaches. These capabilities streamline CRUD (Create, Read, Update, Delete) operations, reducing while maintaining flexibility for complex relationships and validations. The evolution of EF Core began with version 1.0 in June 2016, aligning with .NET Core's initial release to provide a modern ORM foundation. Subsequent versions have introduced enhancements like improved translation and batching in EF Core 2.0 (2017), many-to-many relationships without explicit join entities in 5.0 (2020), and JSON column mapping for SQL Server in 7.0 (2022). With EF Core 8.0 in November 2023 for .NET 8, additions include extended JSON mapping support for primitive collections in , enabling efficient storage and querying of JSON arrays, alongside ongoing improvements to temporal tables introduced in EF Core 6.0 for time-based data versioning. EF Core 9.0, released in November 2024 for .NET 9, brings improvements such as a rewritten provider, enhanced query translations, and better support for ahead-of-time (AOT) compilation and primitive collections. EF Core integrates with various database providers, including the official ones for SQL Server (supporting Azure SQL and SQL Server 2012+), (version 3.46.1+), and (SQL API), as well as the community-maintained Npgsql for . Performance optimizations, such as compiled queries that pre-compile expressions to SQL for reuse, help mitigate query execution overhead in high-load scenarios. Key patterns in EF Core revolve around the DbContext class, which serves as the primary interface for database interactions, managing a unit-of-work scope with configurable lifetime (e.g., scoped per HTTP request). Loading strategies include for on-demand related data retrieval, eager loading via Include() for predefined joins, and explicit loading for controlled fetches; asynchronous methods like ToListAsync() ensure non-blocking operations in I/O-bound contexts. In practice, EF Core excels in CRUD operations for web and desktop applications, such as building REST APIs with or data-driven UIs in WPF, where its abstraction simplifies maintenance without sacrificing control. For read-heavy workloads, using AsNoTracking() disables change tracking to yield gains and reduced memory allocation. While full-featured, it contrasts with lightweight alternatives like for scenarios requiring minimal ORM overhead.

Dapper

Dapper is a lightweight micro-ORM library for .NET that facilitates mapping SQL query results to objects while minimizing boilerplate code associated with . Developed to address performance bottlenecks in high-traffic applications, it emphasizes direct SQL usage without the overhead of full-featured ORMs, making it suitable for scenarios requiring raw query control and speed. By extending the IDbConnection interface, enables developers to execute queries and map results seamlessly across various databases. In terms of design, Dapper operates through extension methods on IDbConnection, allowing queries to be executed directly on existing database connections without introducing new abstractions. It supports multi-mapping, where a single query result set can be split into multiple object types, such as joining parent-child entities in one call. Additionally, it handles stored procedures by accepting command types and parameters, enabling execution of precompiled SQL for optimized performance. Dapper was created in 2011 by the development team to resolve slow page loads caused by ORM inefficiencies, and it was open-sourced shortly thereafter. Integrated into from its early days, the library has seen ongoing contributions, including full asynchronous support in version 1.42 (2015) and enhancements for .NET global tools compatibility up to version 2.1.24 in 2023, with further updates through version 2.1.66 in February 2025 focusing on stability and cross-provider compatibility. Key features include parameterized queries to mitigate risks, dynamic parameters for flexible input handling, and built-in row numbering via query options for . Performance-wise, achieves 3-5 times faster execution than full ORMs like in benchmarks involving large datasets or high-throughput operations, often approaching raw speeds—for instance, handling up to 1 million inserts per second on SQL Server in optimized tests. It integrates effortlessly with any provider, such as those for SQL Server, PostgreSQL, or , requiring no entity tracking, change detection, or schema migrations. Common use cases include high-performance data access in RESTful APIs for and reporting tools that demand quick reads from complex joins. In hybrid setups, it can complement by handling performance-critical queries while leveraging EF for domain modeling.

NHibernate

NHibernate is an open-source object-relational mapping (ORM) framework for the .NET platform, designed to simplify data persistence by mapping .NET objects to relational databases. It implements the patterns and concepts from the Java-based Hibernate ORM, providing a robust layer for handling complex data access scenarios in enterprise applications. As a mature tool, NHibernate supports multiple databases through its extensible architecture, enabling developers to focus on domain logic rather than low-level SQL operations. The core of NHibernate revolves around the ISessionFactory, a thread-safe and immutable component that serves as a cache of compiled mappings for a single database and acts as a factory for ISession instances. The ISession represents a single-threaded, short-lived interaction with the database, managing the first-level cache and wrapping connections for object retrieval and persistence. Querying is facilitated through Hibernate Query Language (HQL), an object-oriented extension of SQL that supports polymorphism, associations, and aggregates, allowing queries like from Cat as cat where cat.Name = 'Fritz' to retrieve instances across class hierarchies. Additionally, the enables dynamic query construction at runtime using an object-oriented approach, such as session.CreateCriteria<Cat>().Add(Expression.Like("Name", "Fritz%")), which is particularly useful for building filters based on user input without embedding strings. Originally ported from Java's Hibernate in 2005, NHibernate has evolved significantly, with version 5.0 released in 2017 introducing asynchronous support for I/O-bound operations and compatibility with , enhancing its suitability for modern cross-platform applications. Subsequent versions, such as 5.4 and later up to 5.6.0 in October 2025, target and beyond, including , ensuring ongoing relevance in contemporary ecosystems. Key features include second-level caching, which shares across sessions via providers like StackExchange. for improved read performance in high-traffic scenarios, configurable through XML elements such as <cache usage="read-write"/> in mappings. defers the retrieval of associated entities until accessed, reducing initial query overhead while integrating seamlessly with caching to maintain consistency. Mapping supports both XML-based definitions for explicit control over class-to-table relationships and convention-based approaches for simpler setups. Extensions like Fluent NHibernate provide a code-based alternative to XML mappings, using fluent APIs to define configurations programmatically, such as Map<T>().Id(x => x.Id).Table("Users"), promoting compile-time safety and reducing boilerplate. Integration with LINQ is achieved through NHibernate.Linq, allowing standard LINQ queries to be translated into HQL or SQL, bridging NHibernate with .NET's query syntax for more idiomatic code. For performance, NHibernate supports batch inserts via HQL DML statements, such as insert into User (Name) select Name from TempUser, which groups multiple operations into fewer database roundtrips to optimize bulk data loading. Query optimization is aided by tools like NHibernate Profiler, which identifies issues such as N+1 select problems and suggests fetch strategies to minimize database hits. NHibernate excels in use cases involving legacy enterprise systems, where its flexible mapping handles intricate schemas evolved over time, and complex domain models requiring advanced features like polymorphic queries and caching for scalability. In contrast to more convention-driven alternatives like , it offers greater customization for challenging persistence requirements.

Numerical and Scientific Libraries

Math.NET Numerics

Math.NET Numerics is an open-source, cross-platform library for numerical, scientific, and engineering computations in the .NET ecosystem, providing implementations for linear algebra, probability models, statistics, optimization, and more. It serves as the numerical foundation of the broader Math.NET project, offering managed code implementations that are extensible via pluggable providers for enhanced performance. The library supports a wide range of .NET frameworks, including .NET Framework, .NET Core, .NET 5+, and .NET Standard 2.0+, making it suitable for both desktop and server applications as of November 2025, with the latest stable version 5.0.0 released in April 2022. The library's core modules include linear algebra for handling vectors and matrices with operations like addition, multiplication, and ; statistics for probability distributions, , and hypothesis testing; and featuring fast Fourier transforms (FFT) for frequency-domain analysis. Key algorithms encompass and QR decompositions for solving linear systems, eigenvalue solvers for stability analysis, and random number generators including the for simulations requiring high-quality pseudorandom sequences. These components emphasize and accuracy, drawing influences from established standards like BLAS and . Initiated in 2009 through the merger of the dnAnalytics and Math.NET Iridium projects, Math.NET Numerics has evolved to support modern .NET standards, with .NET Standard 2.0 compatibility introduced in version 4.0.0 released in 2018. It integrates with Math.NET Symbolics, allowing numerical evaluations of symbolic expressions for hybrid computational workflows. Performance is augmented by native providers such as MKL or , which can deliver significant speedups over the default managed provider in benchmarks for operations like dense . Math.NET Numerics offers strong F# compatibility through idiomatic extensions, enabling concise functional-style code for numerical tasks, and includes comprehensive unit tests using frameworks like to ensure reliability. Common use cases span scientific simulations for modeling physical systems, for and , and for in research applications. It provides foundational primitives that can extend to machine learning workflows via integration with .

Accord.NET

Accord.NET is an open-source framework for scientific computing in the .NET ecosystem, specializing in , statistical analysis, and for audio and image data. It provides a comprehensive set of tools for developing production-grade applications in , computer audition, and , entirely implemented in C#. Originally developed as an extension to the AForge.NET framework—which began in 2006—Accord.NET was first released in 2010 and later incorporated AForge.NET's codebase to form a unified library. By version 3.8.0 in 2017, it introduced enhancements including support for .NET Core through portable packages, enabling cross-platform compatibility starting around 2016. However, the project has not seen major releases since 2017, with the last GitHub commit in November 2020, and is no longer actively maintained as of November 2025. The framework's core components include algorithms such as support vector machines (SVMs) for classification and regression, decision trees with pruning and rule extraction, and clustering methods like k-means and Gaussian mixture models in the Accord.MachineLearning namespace. For statistics, the Accord.Statistics module offers over 40 probability distributions, testing tools including chi-square, t-tests, and ANOVA, as well as models like hidden Markov models (HMMs) and linear/. In and audition, it supports feature extraction via Gabor filters in Accord.Imaging, alongside , filtering, and transformations in Accord.Audio for tasks like real-time . Native interop capabilities allow integration with external libraries, while the framework draws on numerical foundations from Math.NET Numerics for underlying computations in domain-specific applications. Performance is optimized through parallel processing with PLINQ, facilitating efficient handling of large in scenarios such as real-time audio analysis or image feature detection. Built-in like the Iris flower dataset and LoadDigits for handwritten digit recognition enable quick testing and prototyping of algorithms. The framework supports model export formats for , though specific standards like PMML are referenced in older documentation for certain models. Common use cases encompass , such as handwriting and gesture identification using SVMs and HMMs; bioinformatics applications, including DNA sequence prediction with HMMs; and , like brain-controlled wheelchairs via SVM-based interfaces. These applications are evidenced in over 90 academic publications up to 2017, highlighting Accord.NET's historical role in research and practical implementations.

ML.NET

ML.NET is an open-source, cross-platform framework developed by for .NET developers, enabling the creation, training, and deployment of custom models directly within .NET applications without requiring extensive expertise in . It supports a wide range of tasks, including , regression, , and recommendation systems using techniques like matrix factorization, making it suitable for integrating AI capabilities into production environments. The framework was first previewed in May 2018, with version 1.0 released in May 2019, introducing the ML.NET CLI tool for streamlined model experimentation and code generation. Subsequent updates integrated (AutoML) capabilities more deeply starting with .NET 5 in 2020, automating pipeline optimization for better and hyperparameter tuning. As of February 2025, ML.NET version 4.0.2 provides enhanced support for .NET 9 and .NET 10, including improvements in tasks and ONNX interoperability. At the core of ML.NET is the MLContext class, which serves as the entry point for managing workflows, including data loading from various sources like CSV files or databases. Developers build pipelines by chaining data transformations for featurization—such as normalization, encoding, or text —and then applying trainers to fit models to the data. Supported trainers include for in and regression tasks, and FastTree for efficient tree-based learning, allowing for scalable training on large datasets. These pipelines support end-to-end , where is transformed into predictive models ready for in .NET apps. Key features of ML.NET include robust model evaluation through techniques like cross-validation to assess performance metrics such as , ensuring reliable deployment. Models can be serialized to the ONNX format for portability across platforms and frameworks, with tutorials demonstrating integration using .NET 9 and .NET 10 projects. The ML.NET CLI further simplifies experimentation by automatically generating C# code for training and evaluation based on input datasets and tasks. For performance, ML.NET leverages GPU acceleration via integration through ONNX Runtime, optimizing inference for demanding workloads like image classification in real-time applications. Common use cases for ML.NET include predictive maintenance, where models analyze sensor data to forecast equipment failures, often deployed via ASP.NET Core Web APIs for scalable services. Sentiment analysis is another frequent application, enabling real-time classification of text from user comments in web applications built with ASP.NET Core Razor Pages. These integrations highlight ML.NET's strength in embedding machine learning into enterprise .NET ecosystems for tasks requiring low-latency predictions.

Graphics and Image Processing Libraries

OpenTK

OpenTK is a cross-platform, low-level C# library that provides bindings to , audio, and compute APIs, enabling developers to create high-performance applications with direct access to hardware-accelerated rendering and . It serves as a foundation for 3D , audio playback, and tasks within the .NET ecosystem, emphasizing minimal overhead through native wrappers. Originally developed as an evolution of earlier efforts to bring to .NET, OpenTK has become a staple for applications requiring precise control over rendering pipelines and input systems. As the successor to the Tao Framework, which provided initial OpenGL bindings for .NET starting in 2004 and reached its final release in 2008, OpenTK emerged to address limitations in cross-platform compatibility and maintenance. The library's major milestone came with version 3.0 in 2018, introducing support for .NET Standard 2.0 to enable broader portability across .NET Framework, .NET Core, and Mono. Subsequent releases, including version 4.0 in 2020, refined modular packaging and GLFW integration for windowing, while pre-release versions of 5.0, available since 2024 as of November 2025, include native Vulkan bindings for modern graphics APIs. These updates ensure OpenTK remains viable for contemporary .NET development, supporting up to version 4.6, up to 3.2, for audio, for compute, and for cross-platform window management. The latest stable release is 4.9.4 (March 2025). Key features include a comprehensive with types such as vectors, matrices, and quaternions for 3D transformations, alongside utilities for shader compilation, linking, and uniform management via contexts. Input handling covers keyboard, , events, and window resizing through event-driven , facilitating responsive user interactions in real-time applications. Performance is optimized via direct, high-speed calls, bypassing higher-level abstractions; for instance, simple 3D scene rendering with vertex buffers and shaders can achieve over 120 frames per second on modern GPUs like series, as demonstrated in uncapped benchmarks for voxel-based engines. OpenTK supports deployment on Windows, , macOS, *BSD, and , with experimental wrappers available for Android through community extensions. Common use cases encompass game engine development, such as the voxel-based , computer-aided design (CAD) tools for , and scientific visualization applications like molecular rendering or data plotting, where low-level control over hardware enhances efficiency and customization.

ImageSharp

ImageSharp is a fully managed, cross-platform 2D library for .NET, designed to simplify image loading, , and manipulation while providing high and extensibility. Since version 3.0, it operates under the Six Labors Split , free for open-source, non-profits, and small companies (under $1M annual revenue), but requiring a paid license key for larger commercial use, with enforcement in version 4.0 and later. It serves as a modern alternative to legacy libraries like System.Drawing, supporting a wide range of scenarios from desktop applications to services and embedded devices. Built against .NET Standard 2.0 and later versions, it enables developers to perform operations without platform-specific dependencies. The library supports reading and writing multiple image formats, including , , , BMP, TIFF, , TGA, PBM, and QOI, with automatic format detection during loading. It includes comprehensive metadata handling, such as profiles for exchangeable image file format data and ICC profiles for color management in formats like . Key operations encompass resizing with algorithms like Lanczos for high-quality scaling, applying filters such as for effects like softening, and efficient pixel-level access through Span for low-level manipulation. Additional features include animation support for and animated () formats, enabling frame-by-frame processing and encoding; drawing capabilities for lines, shapes, and text via the ImageSharp.Drawing extension; and color space conversions between models like RGB, CMYK, and CIE XYZ using dedicated converter classes. Development of ImageSharp began in 2016 as an open-source project under Six Labors, with initial releases focusing on core decoding and encoding. It adopted .NET Standard 2.0 compatibility in 2018 to broaden cross-platform support, culminating in a stable 1.0 release in 2020. Subsequent versions introduced significant optimizations: version 2.0 in 2022 achieved 3x overall performance gains over in benchmarks, leveraging unsafe code for memory access and reduced allocations (10 KB native memory vs. 11,376 KB for ). Version 3.0 in 2023 targeted .NET 6 and added SIMD hardware intrinsics like AVX2, yielding up to 14.4x speedup in and 2x in color matrix operations, with further enhancements in .NET 7 and later for vectorized processing. Version 3.1 in late 2023 added further optimizations; as of September 2025, version 4.0 introduces stricter license enforcement for commercial use. Common use cases for ImageSharp include building photo editing tools for applying filters and metadata adjustments, generating thumbnails in web applications via on-the-fly resizing, and performing for converting or optimizing large image sets in server environments.

SkiaSharp

SkiaSharp is a cross-platform 2D graphics library for .NET platforms, providing bindings to Google's Skia Graphics Library for high-performance rendering of images and across mobile, desktop, and server environments. It was first announced and released on February 22, 2016, as a replacement for legacy drawing APIs like System.Drawing and Mono.Cairo, enabling developers to leverage Skia's stable C API for consistent results. The library has evolved significantly, with version 2.88 released in 2023 introducing enhanced compatibility with .NET 8 and support for the Metal backend on macOS via SKMetalView for improved hardware-accelerated rendering on Apple platforms. As of 2025, the latest stable version is 3.119.1 (September 2025), maintaining backward compatibility with .NET Standard 2.0 and targeting modern frameworks like .NET 6, .NET 8, and .NET 9. At its core, SkiaSharp's revolves around the SKCanvas class, which serves as the primary interface for drawing paths using SKPath, applying paints via SKPaint for styling, and rendering text with SKTextBlob or direct string methods. It supports import through SKSvgCanvas for parsing and rendering from files, and PDF export via SKDocument, allowing creation of multi-page documents with embedded vector content. Key features include for smooth edges on lines and shapes, gradient fills through SKShader for linear, radial, and sweep patterns, and advanced font rendering powered by HarfBuzz integration for complex text shaping, ligatures, and bidirectional support. Hardware acceleration is enabled via GRContext backends, supporting for cross-platform GPU rendering and for Windows-specific optimization, reducing CPU load in demanding scenarios. In terms of performance, SkiaSharp achieves high frame rates for 2D rendering, with benchmarks showing uncapped rates exceeding 1000 FPS for simple scenes on capable hardware, making it suitable for real-time applications. It integrates seamlessly with and .NET MAUI through dedicated view packages like SkiaSharp.Views.Maui.Controls, enabling efficient drawing in cross-platform apps. The library supports all major .NET platforms, including Windows (via WinUI 3 and classic desktop), Android, , macOS, tvOS, and , with platform-specific views for native integration. Common use cases encompass developing custom UI controls, generating dynamic charts and graphs, and creating vector illustrations for apps requiring precise, scalable graphics. For raster operations, it can combine with libraries like ImageSharp for image loading prior to canvas manipulation.

Testing and Quality Assurance Frameworks

NUnit

is an open-source framework for .NET languages, designed to support (TDD) by enabling developers to write and execute automated tests for verifying code behavior. Originally ported from for , it provides a structured approach to defining test fixtures, individual tests, and setup/teardown logic through attributes, allowing for repeatable and isolated testing of application components. The framework's evolution began with version 1.0 released in 2002, establishing foundational support for basic assertions and test execution in early .NET environments. Significant advancements came with NUnit 3.0 in November 2015, which introduced full compatibility with .NET Core and cross-platform execution on Windows, , and macOS, alongside enhanced extensibility for modern development workflows. The latest major release, NUnit 4.4.0 in August 2025, includes bug fixes and enhancements building on 4.0 (November 2023), with refinements to assertion handling, async/await integration, and improved error messaging while maintaining . Key features of NUnit include attribute-based test definition, such as the [TestFixture] attribute for classes containing tests, [Test] for individual test methods, and [SetUp] for methods executed before each test to initialize state. Parallel execution is enabled via the [Parallelizable] attribute, allowing tests to run concurrently at fixture, class, or assembly levels to improve throughput on multi-core systems, while the [Theory] attribute supports parameterized and data-driven tests by combining test methods with data sources like [TestCase] or [Datapoint] for validating behavior across multiple inputs. The Assert API emphasizes constraint-based assertions, exemplified by Assert.That(actual, Is.EqualTo(expected)), which provides detailed failure messages through a chainable syntax for equality, collection, or type checks; custom matchers can be implemented by extending the IConstraint interface for domain-specific validations. Mocking is facilitated through third-party extensions like NSubstitute or Moq, integrated seamlessly with NUnit's test runner, and test results are output in XML format for parsing and reporting. NUnit integrates natively with Visual Studio's Test Explorer via the NUnit3 Test Adapter NuGet package, enabling seamless test discovery, execution, and debugging within the IDE. For continuous integration and deployment (), it supports Azure DevOps pipelines through the dotnet test command or the NUnit console runner, allowing automated test runs with result publication and failure tracking in build workflows. Performance optimizations ensure efficient test discovery and execution, with constraints enabling flexible custom matchers to avoid overhead in complex validations. Common use cases for NUnit include TDD in web and desktop .NET projects, where developers write tests alongside code to ensure reliability during refactoring, and data-driven testing for scenarios like API validation or business logic verification across varied inputs using theories.

xUnit.net

xUnit.net is a free, open-source unit testing framework for .NET languages including C#, F#, and Visual Basic, prioritizing simplicity, extensibility, and alignment with modern development practices. Developed by Brad Wilson and Jim Newkirk, the original creator of NUnit v2, it was first released in 2007 as a successor to NUnit 2.x, addressing issues like tight coupling to base classes and complex configuration requirements. The framework's core structure revolves around attributes for defining tests: the [Fact] attribute marks parameterless tests that represent invariant conditions, while [Theory] enables by combining with data attributes like [InlineData] to parameterize test methods with specific inputs, allowing multiple executions from a single method. For within tests, ITestOutputHelper provides an interface to capture and output diagnostic information, such as console writes, which is accessible via constructor injection without relying on static methods. This design promotes test isolation and readability, avoiding shared state unless explicitly configured. Key features include the [Trait] attribute for categorizing tests with key-value pairs, facilitating filtering and organization in large suites; collection fixtures, which enable shared setup and teardown across multiple test classes via ICollectionFixture<T> implementations to manage expensive resources like databases; and extensibility through ITestCaseOrderer, an interface allowing custom ordering of test cases within a class for scenarios requiring sequential execution. Starting from version 2.4 in 2018, xUnit.net added enhanced support for Core, providing full compatibility with .NET 5 and later versions, including improvements to asynchronous test handling. The major version 3.0, released in July 2025, introduced support for .NET 8+, new project templates, skipping test assertions, and overloads for collections. xUnit.net integrates seamlessly with development environments through built-in runners: the Visual Studio adapter via the xunit.runner.visualstudio package enables test discovery and execution directly in the Test Explorer without additional setup, while native support in JetBrains ReSharper and Rider allows running and debugging tests from the IDE's unit test window. Unlike some frameworks, it requires no XML configuration files, relying instead on optional JSON-based settings for assembly-level customization. Performance-wise, xUnit.net offers faster test discovery and execution compared to , particularly for parallel runs enabled by default, and supports inline data attributes efficiently for small datasets to minimize overhead. It is particularly suited for isolation-focused testing in architectures and reusable libraries, where and minimal setup promote clean, maintainable test code.

FluentAssertions

FluentAssertions is a .NET library that provides a set of extension methods enabling developers to express assertions in unit tests using a fluent, syntax, particularly suited for (TDD) and (BDD) styles. It extends common test frameworks by offering readable alternatives to traditional assert statements, such as actual.Should().BeEquivalentTo(expected) for deep structural comparisons, which automatically handles object graphs and collections without requiring manual property checks. This approach improves test maintainability by producing detailed failure messages that explain discrepancies, including reasons for assertion failures like mismatched properties or collection orders. The library originated in 2011 as an open-source project aimed at enhancing assertion readability in .NET unit tests. Its evolution includes significant updates in version 6.12.0, released in August 2023, which introduced custom comparers for assertions like Be, NotBe, and BeOneOf, alongside improved formatting for record types to better handle C# value-based equality semantics. Further advancements came with version 8.0 in February 2025, adding official support for .NET 8 and enhanced record type comparisons, including member-based equivalency for nested structures; starting with this version, it requires a paid license for commercial use (free for open-source and non-commercial projects), while maintaining compatibility with earlier .NET versions starting from .NET Standard 2.0. The latest release as of November 2025 is version 8.8.0, including additional bug fixes and features like support for System.Text.Json.JsonNode. Key features include support for asynchronous assertions, such as await act.Should().ThrowAsync<InvalidOperationException>() to verify exceptions in async methods, which unwraps AggregateException automatically for cleaner verification. Deep equality assertions for collections use BeEquivalentTo to recursively compare elements, ignoring order by default but allowing strict ordering via WithStrictOrdering(), and providing diagnostics for complex mismatches like differing nested objects. Customization is facilitated through interfaces like IAssertionRule, enabling users to define bespoke equality rules for specific types during equivalency checks, such as ignoring cyclic references or applying domain-specific comparators. FluentAssertions integrates seamlessly with popular .NET testing frameworks including , xUnit.net, and MSTest, automatically detecting the host framework and formatting output with contextual reason messages for easier . It can be used alongside core frameworks like to enhance assertion expressiveness without altering test structure. Performance impact is negligible in typical unit test scenarios, as the overhead of fluent chaining and deep comparisons is minimal compared to the readability gains, though it may introduce slight costs for very large object graphs during diagnostics. In practice, FluentAssertions excels in BDD-style tests by allowing chained assertions that read like specifications, such as verifying business rules in large test suites: result.Should().NotBeNull().And.HaveProperty(x => x.Status).Which.Should().Be("Success"). This promotes clearer intent and faster failure diagnosis, making it ideal for maintaining extensive test bases in enterprise .NET applications where readability directly impacts development velocity.

Utility and Cross-Cutting Libraries

AutoMapper

AutoMapper is a convention-based object-object mapper library for .NET applications, designed to simplify the transformation of data between different object types, such as domain entities to data transfer objects (DTOs). It uses a fluent to configure mappings based on naming conventions, reducing the need for manual property assignments and in scenarios like responses or query projections. Originally developed by Jimmy Bogard, the library emphasizes model projection to flatten complex domain models into simpler representations for transport or display. The library's evolution began with its initial 1.0 release in February 2010, providing foundational support for .NET Framework applications. Subsequent versions have expanded compatibility and performance, with version 12.0 released in September 2022 targeting .NET 6 and later, and version 15.0 in July 2025 supporting .NET 8, .NET 9, and .NET Standard 2.0. The latest version, 15.1.0, was released on October 24, 2025. Starting with version 15.0, AutoMapper requires a license key under a dual commercial/open-source model; developers must obtain a key from the official site and configure it, such as via cfg.LicenseKey = "<License Key Here>" in MapperConfiguration. Key advancements include enhanced configuration validation for compile-time-like safety checks during development, such as AssertConfigurationIsValid() to detect mapping errors early, preventing runtime surprises. Mapping configurations in AutoMapper are typically organized into profiles—classes that inherit from the Profile base class—to group related mappings logically and promote reusability across assemblies. For example, a profile might define CreateMap<SourceType, DestinationType>() to establish a basic convention-based mapping, with options to ignore specific properties via .ForMember(dest => dest.Property, opt => opt.Ignore()) or implement custom logic through value resolvers implementing IValueResolver<TSource, TDestination, TMember>. Reverse mapping is supported by explicitly configuring the inverse direction with CreateMap<DestinationType, SourceType>() or appending .ReverseMap() to an existing map, enabling bidirectional transformations like unflattening nested properties. Additionally, AutoMapper integrates LINQ expression support through methods like ProjectTo<TDestination>(IConfigurationProvider), which translates mappings into efficient Select projections for IQueryable sources, avoiding full materialization of entities. Performance optimizations in AutoMapper include compiled mappings, where expression trees are pre-compiled into delegates at configuration time, significantly reducing runtime overhead compared to pure reflection. Version 5.0 introduced major speed improvements, with benchmarks showing up to 20 times faster execution for complex mappings, making it suitable for high-throughput scenarios; for instance, mapping collections of 1000 simple objects typically completes in under 10 milliseconds on modern hardware. These compiled maps establish critical context for in data-intensive applications. AutoMapper integrates seamlessly with Core for query projections, allowing ProjectTo on IQueryable to shape results directly in the database, minimizing data transfer and improving efficiency in read-heavy operations. It also supports in ASP.NET Core via services.AddAutoMapper(assemblies), enabling IMapper injection into controllers or services for automated mapping in request handling. Common use cases include layer transformations, where it maps domain models to DTOs for serialization, and reducing boilerplate in microservices architectures by standardizing object conversions across bounded contexts. For debugging, mapped objects can be logged using libraries like Serilog to trace transformations during development.

Serilog

Serilog is a popular open-source diagnostic library for .NET applications, emphasizing structured that captures log events as rich, queryable data rather than plain text strings. It supports writing logs to various outputs through extensible "sinks," enabling integration with storage systems, consoles, and tools, while maintaining portability across modern .NET platforms like .NET Core and .NET 5+. Developed initially by Nicholas Blumhardt, Serilog was created in 2012 to address limitations in traditional by introducing message templates for consistent, parameterized event capture. Its evolution has focused on and compatibility; for instance, version 3.0, released in 2023, dropped support for legacy .NET Framework versions and introduced enhancements for .NET 8, including improved async processing for better throughput in high-load scenarios. Subsequent updates, such as version 4.3.0 in May 2025, unpinned the assembly version from the historical 2.0.0 to align with semantic versioning practices. The library's centers on a fluent, type-safe approach to structured events, using message templates with placeholders for properties. For example, developers can log with Log.[Information](/page/Information)("{Property} is {Value}", prop, value) to capture key-value pairs, or employ the @ prefix for destructuring complex objects, such as Log.[Information](/page/Information)("Processed {@Position} in {Elapsed:000} ms.", position, elapsedMs), which serializes the Position object into a JSON-like like {"Position": {"[Latitude](/page/Latitude)": 25, "[Longitude](/page/Longitude)": 134}, "Elapsed": 34}. This avoids string concatenation overhead and facilitates searching and analysis in downstream systems. Configuration is handled via LoggerConfiguration, allowing setup of minimum log levels (e.g., .MinimumLevel.[Information](/page/Information)() to suppress debug messages), event filtering with predicates, and batching in sinks to optimize I/O operations. Serilog extends through sinks and enrichers for flexible output and context addition. Common sinks include the console sink for development output, the file sink for persistent rolling logs, Seq for structured log aggregation and querying, and the Application Insights sink for Azure-based telemetry integration. Enrichers enhance every log event with ambient data, such as user identifiers via custom enrichers or automatic correlation IDs through LogContext.PushProperty("UserId", userId) for tracing request flows. These components support features like asynchronous writing to prevent blocking and conditional rendering to minimize allocation when logs are filtered out at the source. Performance is a core strength, with Serilog designed for low overhead in production environments; when logging is disabled below the minimum level, it incurs negligible CPU cost, often under 1% in typical workloads. Benchmarks demonstrate its efficiency, achieving over 10,000 log events per second in structured scenarios with minimal latency compared to alternatives like NLog, particularly when using batched sinks. In practice, Serilog excels in for cloud-native .NET applications, where structured logs enable correlation with distributed traces via integrations like OpenTelemetry, facilitating root-cause analysis across . For instance, in Azure-hosted apps, logs sent to Application Insights can link events to traces, providing end-to-end visibility into request lifecycles and errors.

Polly

Polly is a .NET resilience and transient-fault-handling library that enables developers to define and apply policies for managing failures in distributed systems, such as retries for temporary network issues or circuit breaking to prevent overload. Hosted under the .NET Foundation, it provides thread-safe implementations targeting .NET Standard 1.1 and later, including full support for asynchronous operations across .NET Framework, .NET Core, and .NET 5+. By encapsulating common resilience patterns in a fluent , Polly simplifies building robust applications without custom boilerplate code. The library's core strength lies in its policy-based approach, where developers can chain multiple strategies to handle diverse fault scenarios. For instance, a retry policy can be combined with a fallback to ensure graceful degradation during outages. has evolved significantly since its inception, with ongoing updates focused on performance optimization and integration with modern .NET features like . Key policies in include the Retry policy, which supports to progressively delay retries—starting with short waits that double in duration (e.g., 2 seconds, then 4, 8) up to a configurable maximum—reducing contention in concurrent environments. The policy monitors failure rates and "opens" after a threshold (e.g., 5 consecutive failures within 30 seconds), blocking calls for a cooldown period to allow recovery before "half-open" testing resumes normal operation. Bulkhead isolation limits concurrent executions to protect shared resources, akin to a , preventing one failing component from exhausting system capacity. Fallback policies execute alternative logic, such as returning cached data, when primary operations fail, while Timeout policies enforce upper bounds on execution duration to avoid indefinite hangs. Polly's initial version 1.0.0 was released on May 5, 2013, introducing basic retry and capabilities for .NET 3.5 and 4.x. By version 8.0, released on November 7, 2023, it incorporated resilience pipelines for composing strategies, a registry via ResiliencePipelineProvider for centralized management, and native telemetry integration, optimized for .NET 8. These updates emphasize declarative configuration and reduced overhead, with subsequent releases like 8.6.4 in September 2025 enhancing stability. Features such as async support allow seamless use in asynchronous code paths, handling Task-based operations without blocking threads, while custom exception filtering (e.g., retrying only on SqlException) enables precise fault targeting. Policy chaining facilitates complex workflows, like applying a Retry policy followed by Fallback, executed via Policy.WrapAsync or modern pipeline builders. Configuration leverages a fluent for readability, as in var retryPolicy = Policy.Handle<SqlException>().WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));, which defines three retries with . In .NET's , policies integrate via services.AddResiliencePipeline("http-resilience", builder => builder.AddRetry(new RetryStrategyOptions { Delay = TimeSpan.FromSeconds(1) }));, supporting metrics collection for . Performance benchmarks demonstrate negligible latency overhead, with pipeline executions averaging 2.089 microseconds in version 8 versus 2.277 in prior versions, and allocations as low as 40 bytes per invocation in high-throughput tests combining multiple policies. This supports 99.9% uptime in scenarios with frequent transient faults, as validated in benchmarks like eShopOnContainers. Common use cases include retrying HTTP calls in APIs to tolerate network glitches, such as 503 errors from downstream services, and database retries for connection timeouts in high-availability setups. In architectures, Polly enhances reliability by isolating failures and enabling bulkhead controls to maintain overall system throughput during partial outages.

References

  1. https://dotnet.microsoft.com/en-us/
  2. https://www.nuget.org/
  3. https://learn.microsoft.com/en-us/nuget/policies/ecosystem
  4. https://learn.microsoft.com/en-us/dotnet/standard/class-library-overview
  5. https://learn.microsoft.com/en-us/aspnet/core/overview?view=aspnetcore-9.0
  6. https://learn.microsoft.com/en-us/ef/core/
  7. https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-10/overview
  8. https://dotnet.microsoft.com/en-us/learn/dotnet/what-is-dotnet
  9. https://learn.microsoft.com/en-us/dotnet/standard/glossary
  10. https://learn.microsoft.com/en-us/dotnet/core/introduction
  11. https://devblogs.microsoft.com/dotnet/announcing-net-core-1-0/
  12. https://devblogs.microsoft.com/dotnet/announcing-net-5-0/
  13. https://learn.microsoft.com/en-us/lifecycle/products/microsoft-net-and-net-core
  14. https://devblogs.microsoft.com/dotnet/announcing-net-10/
  15. https://learn.microsoft.com/en-us/dotnet/standard/clr
  16. https://learn.microsoft.com/en-us/dotnet/standard/class-libraries
  17. https://learn.microsoft.com/en-us/dotnet/standard/assembly/
  18. https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-9/
  19. https://learn.microsoft.com/en-us/aspnet/core/overview?view=aspnetcore-10.0
  20. https://learn.microsoft.com/en-us/aspnet/core/release-notes/aspnetcore-6.0?view=aspnetcore-10.0
  21. https://learn.microsoft.com/en-us/aspnet/core/fundamentals/?view=aspnetcore-10.0
  22. https://learn.microsoft.com/en-us/aspnet/core/fundamentals/servers/kestrel?view=aspnetcore-10.0
  23. https://learn.microsoft.com/en-us/aspnet/core/fundamentals/routing?view=aspnetcore-10.0
  24. https://learn.microsoft.com/en-us/aspnet/core/security/authentication/identity?view=aspnetcore-10.0
  25. https://www.techempower.com/benchmarks/#section=data-r23
  26. https://learn.microsoft.com/en-us/aspnet/core/grpc/aspnetcore?view=aspnetcore-10.0
  27. https://learn.microsoft.com/en-us/aspnet/core/signalr/introduction?view=aspnetcore-10.0
  28. https://learn.microsoft.com/en-us/dotnet/core/deploying/
  29. https://learn.microsoft.com/en-us/aspnet/core/host-and-deploy/azure-apps/?view=aspnetcore-10.0
  30. https://learn.microsoft.com/en-us/aspnet/core/blazor/?view=aspnetcore-10.0
  31. https://dotnet.microsoft.com/en-us/apps/aspnet/web-apps/blazor
  32. https://learn.microsoft.com/en-us/aspnet/core/blazor/hosting-models?view=aspnetcore-10.0
  33. https://learn.microsoft.com/en-us/aspnet/core/blazor/components/?view=aspnetcore-10.0
  34. https://learn.microsoft.com/en-us/aspnet/core/blazor/state-management/?view=aspnetcore-10.0
  35. https://devblogs.microsoft.com/dotnet/blazor-0-5-0-experimental-release-now-available/
  36. https://devblogs.microsoft.com/dotnet/blazor-now-in-official-preview/
  37. https://devblogs.microsoft.com/dotnet/blazor-webassembly-3-2-0-now-available/
  38. https://learn.microsoft.com/en-us/aspnet/core/blazor/performance/app-download-size?view=aspnetcore-10.0
  39. https://learn.microsoft.com/en-us/aspnet/core/blazor/performance/?view=aspnetcore-10.0
  40. https://learn.microsoft.com/en-us/aspnet/core/blazor/progressive-web-app/?view=aspnetcore-10.0
  41. https://learn.microsoft.com/en-us/aspnet/signalr/overview/getting-started/introduction-to-signalr
  42. https://learn.microsoft.com/en-us/aspnet/core/blazor/fundamentals/signalr?view=aspnetcore-10.0
  43. https://learn.microsoft.com/en-us/aspnet/core/signalr/hubs?view=aspnetcore-10.0
  44. https://learn.microsoft.com/en-us/aspnet/core/signalr/groups?view=aspnetcore-10.0
  45. https://learn.microsoft.com/en-us/aspnet/core/signalr/redis-backplane?view=aspnetcore-10.0
  46. https://learn.microsoft.com/en-us/aspnet/core/signalr/authn-and-authz?view=aspnetcore-10.0
  47. https://learn.microsoft.com/en-us/aspnet/core/signalr/configuration?view=aspnetcore-10.0
  48. https://learn.microsoft.com/en-us/dotnet/desktop/winforms/overview/
  49. https://learn.microsoft.com/en-us/dotnet/api/system.windows.forms?view=windowsdesktop-9.0
  50. https://learn.microsoft.com/en-us/dotnet/framework/install/versions-and-dependencies
  51. https://learn.microsoft.com/en-us/dotnet/desktop/winforms/whats-new/net90
  52. https://learn.microsoft.com/en-us/dotnet/desktop/winforms/data/overview
  53. https://learn.microsoft.com/en-us/dotnet/api/system.windows.forms.form?view=windowsdesktop-9.0#System_Windows_Forms_Form_IsMdiContainer
  54. https://learn.microsoft.com/en-us/dotnet/desktop/winforms/advanced/windows-forms-accessibility
  55. https://learn.microsoft.com/en-us/dotnet/desktop/winforms/high-dpi-support-in-windows-forms
  56. https://learn.microsoft.com/en-us/windows/win32/hidpi/high-dpi-desktop-application-development-on-windows
  57. https://learn.microsoft.com/en-us/dotnet/desktop/wpf/overview/
  58. https://learn.microsoft.com/en-us/dotnet/desktop/wpf/advanced/graphics-rendering-tiers
  59. https://learn.microsoft.com/en-us/dotnet/desktop/wpf/whats-new/
  60. https://learn.microsoft.com/en-us/dotnet/desktop/wpf/whats-new/framework45
  61. https://learn.microsoft.com/en-us/dotnet/maui/what-is-maui?view=net-maui-9.0
  62. https://learn.microsoft.com/en-us/dotnet/maui/supported-platforms?view=net-maui-9.0
  63. https://dotnet.microsoft.com/en-us/apps/xamarin/xamarin-forms
  64. https://learn.microsoft.com/en-us/dotnet/communitytoolkit/maui/
  65. https://learn.microsoft.com/en-us/dotnet/maui/whats-new/dotnet-9?view=net-maui-9.0
  66. https://learn.microsoft.com/en-us/dotnet/maui/fundamentals/single-project?view=net-maui-9.0
  67. https://learn.microsoft.com/en-us/dotnet/maui/get-started/installation?view=net-maui-9.0
  68. https://learn.microsoft.com/en-us/dotnet/maui/deployment/visual-studio-properties?view=net-maui-10.0
  69. https://dotnet.microsoft.com/en-us/apps/maui
  70. https://learn.microsoft.com/en-us/dotnet/maui/user-interface/controls/blazorwebview?view=net-maui-9.0
  71. https://learn.microsoft.com/en-us/ef/efcore-and-ef6/
  72. https://learn.microsoft.com/en-us/ef/core/modeling/
  73. https://learn.microsoft.com/en-us/ef/core/what-is-new/
  74. https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-8.0/whatsnew
  75. https://learn.microsoft.com/en-us/ef/core/providers/sql-server/temporal-tables
  76. https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-9.0/whatsnew
  77. https://learn.microsoft.com/en-us/ef/core/providers/
  78. https://learn.microsoft.com/en-us/ef/core/querying/tracking#no-tracking-queries
  79. https://learn.microsoft.com/en-us/ef/core/performance/efficient-querying
  80. https://github.com/DapperLib/Dapper
  81. https://www.infoq.com/news/2011/04/dapper-released/
  82. https://www.nuget.org/packages/dapper/
  83. https://www.learndapper.com/stored-procedures
  84. https://www.nuget.org/packages/Dapper/2.1.24
  85. https://www.linkedin.com/pulse/ef-core-vs-dapper-when-use-each-practical-performance-hernandes-kxupf
  86. https://www.c-sharpcorner.com/article/dapper-unveiled-the-lightweight-orm-powering-high-performance-net-applications/
  87. https://developersvoice.com/blog/dotnet/dapper-ef-hybrid-data-access-performance/
  88. https://nhibernate.info/
  89. https://nhibernate.info/doc/nhibernate-reference/architecture.html
  90. https://nhibernate.info/doc/nhibernate-reference/queryhql.html
  91. https://nhibernate.info/doc/nhibernate-reference/querycriteria.html
  92. https://sourceforge.net/projects/nhibernate/
  93. https://nhibernate.info/blog/2017/10/10/nhibernate-5-0-released.html
  94. https://www.nuget.org/packages/nhibernate
  95. https://nhibernate.info/doc/nhibernate-reference/caches.html
  96. https://github.com/nhibernate/fluent-nhibernate
  97. https://nhibernate.info/doc/nhibernate-reference/batch.html
  98. https://hibernatingrhinos.com/products/nhprof/learn
  99. https://numerics.mathdotnet.com/
  100. https://github.com/mathnet/mathnet-numerics
  101. https://numerics.mathdotnet.com/Compatibility.html
  102. https://www.nuget.org/packages/mathnet.numerics/
  103. https://numerics.mathdotnet.com/api/
  104. https://numerics.mathdotnet.com/Contributors
  105. https://symbolics.mathdotnet.com/
  106. https://christoph.ruegg.name/blog/mathnet-numerics-with-native-linear-algebra
  107. http://accord-framework.net/intro.html
  108. https://github.com/accord-net/framework
  109. https://glossarytech.com/terms/c-net/accordnet-framework
  110. https://github.com/accord-net/framework/issues/318
  111. http://accord-framework.net/docs/html/R_Project_Accord_NET.htm
  112. http://accord-framework.net/docs/N_Accord_Statistics.htm
  113. http://accord-framework.net/docs/N_Accord_MachineLearning.htm
  114. http://accord-framework.net/docs/N_Accord_Imaging.htm
  115. http://accord-framework.net/publications.html
  116. http://www.codeproject.com/Articles/74348/
  117. http://socs.binus.ac.id/files/2016/09/D.pdf
  118. https://learn.microsoft.com/en-us/dotnet/machine-learning/overview
  119. https://learn.microsoft.com/en-us/dotnet/machine-learning/resources/tasks
  120. https://devblogs.microsoft.com/dotnet/announcing-ml-net-1-0/
  121. https://learn.microsoft.com/en-us/dotnet/machine-learning/automated-machine-learning-mlnet
  122. https://github.com/dotnet/machinelearning/releases/tag/v4.0.2
  123. https://learn.microsoft.com/en-us/dotnet/machine-learning/whats-new/overview
  124. https://learn.microsoft.com/en-us/dotnet/machine-learning/mldotnet-api
  125. https://learn.microsoft.com/en-us/dotnet/machine-learning/tutorials/object-detection-onnx
  126. https://learn.microsoft.com/en-us/dotnet/machine-learning/automate-training-with-cli
  127. https://www.c-sharpcorner.com/article/predictive-maintenance-an-ai-powered-approach-using-net-and-ml-net/
  128. https://learn.microsoft.com/en-us/dotnet/machine-learning/tutorials/sentiment-analysis-model-builder
  129. https://dotnet.microsoft.com/en-us/apps/ai/ml-dotnet
  130. https://github.com/opentk/opentk
  131. https://github.com/opentk/opentk/releases
  132. https://opentk.net/
  133. https://opentk.net/learn/
  134. https://www.nuget.org/packages/OpenTK/
  135. https://opentk.net/resources.html
  136. https://github.com/SixLabors/ImageSharp
  137. https://docs-v2.sixlabors.com/articles/imagesharp/index.html
  138. https://docs.sixlabors.com/articles/imagesharp/imageformats.html
  139. https://docs.sixlabors.com/api/ImageSharp/SixLabors.ImageSharp.Metadata.Profiles.Exif.ExifProfile.html
  140. https://github.com/SixLabors/ImageSharp/issues/74
  141. https://docs.sixlabors.com/articles/imagesharp/resize.html
  142. https://docs.sixlabors.com/api/ImageSharp/SixLabors.ImageSharp.Processing.GaussianBlurExtensions.html
  143. https://docs.sixlabors.com/articles/imagesharp/animatedgif.html
  144. https://sixlabors.com/posts/announcing-imagesharp-310/
  145. https://docs.sixlabors.com/api/ImageSharp/SixLabors.ImageSharp.ColorSpaces.Conversion.ColorSpaceConverter.html
  146. https://github.com/SixLabors/ImageSharp.Drawing
  147. https://github.com/SixLabors/ImageSharp/issues/8
  148. https://sixlabors.com/posts/announcing-imagesharp-100/
  149. https://sixlabors.com/posts/announcing-imagesharp-200/
  150. https://sixlabors.com/posts/announcing-imagesharp-300/
  151. https://sixlabors.com/posts/licence-enforcement-changes/
  152. https://github.com/SixLabors/Samples/tree/main/ImageSharp
  153. https://github.com/mono/SkiaSharp
  154. https://devblogs.microsoft.com/xamarin/cross-platform-2d-graphics-with-skiasharp/
  155. https://www.nuget.org/packages/SkiaSharp/
  156. https://learn.microsoft.com/en-us/dotnet/api/skiasharp.skcanvas?view=skiasharp-2.88
  157. https://learn.microsoft.com/en-us/dotnet/api/skiasharp.sksvgcanvas?view=skiasharp-2.88
  158. https://learn.microsoft.com/en-us/dotnet/api/skiasharp.skdocument?view=skiasharp-2.88
  159. https://www.nuget.org/packages/SkiaSharp.HarfBuzz/
  160. https://skiasharp.com/
  161. https://github.com/mono/SkiaSharp/issues/533
  162. https://www.telerik.com/blogs/your-first-steps-skiasharp-net-maui
  163. https://nunit.org/
  164. https://docs.nunit.org/articles/nunit/release-notes/framework.html
  165. https://docs.nunit.org/articles/nunit/release-notes/Pre-3.5-Release-Notes.html
  166. https://docs.nunit.org/articles/nunit/writing-tests/attributes/testfixture.html
  167. https://docs.nunit.org/articles/nunit/writing-tests/attributes/test.html
  168. https://docs.nunit.org/articles/nunit/writing-tests/attributes/setup.html
  169. https://docs.nunit.org/articles/nunit/technical-notes/usage/Framework-Parallel-Test-Execution.html
  170. https://docs.nunit.org/articles/nunit/writing-tests/attributes/theory.html
  171. https://docs.nunit.org/articles/nunit/writing-tests/assertions/assertions.html
  172. https://docs.nunit.org/articles/nunit/extending-nunit/Custom-Constraints.html
  173. https://docs.nunit.org/articles/nunit/technical-notes/usage/Test-Result-XML-Format.html
  174. https://docs.nunit.org/articles/vs-test-adapter/Usage.html
  175. https://docs.nunit.org/articles/vs-test-adapter/Index.html
  176. https://learn.microsoft.com/en-us/dotnet/core/testing/unit-testing-csharp-with-nunit
  177. https://xunit.net/
  178. https://www.nuget.org/packages/xunit
  179. https://www.testim.io/blog/xunit-vs-nunit/
  180. https://xunit.net/docs/getting-started/v2/getting-started
  181. https://xunit.net/docs/capturing-output
  182. https://xunit.net/docs/shared-context
  183. https://xunit.net/releases/v3/3.0.0
  184. https://xunit.net/docs/getting-started/v3/whats-new
  185. https://www.jetbrains.com/help/resharper/Reference_Options_Tools_Unit_Testing_xUnit.html
  186. https://www.jetbrains.com/help/rider/Reference_Options_Tools_Unit_Testing_xUnit.html
  187. https://www.headspin.io/blog/nunit-vs-xunit-vs-mstest
  188. https://www.fluentassertions.com/introduction
  189. https://www.fluentassertions.com/objectgraphs/
  190. https://www.dennisdoomen.com/2011/10/fluent-assertions-is-finally-gaining.html
  191. https://www.nuget.org/packages/fluentassertions/6.12.0
  192. https://www.fluentassertions.com/upgradingtov8
  193. https://xceed.com/products/unit-testing/fluent-assertions/
  194. https://www.nuget.org/packages/fluentassertions/
  195. https://www.fluentassertions.com/exceptions/
  196. https://www.damirscorner.com/blog/posts/20141117-CreatingACustomIassertionRuleForFluentAssertions.html
  197. https://stackoverflow.com/questions/49724379/should-fluentassertions-be-used-in-production-code
  198. https://dev.to/fabriziobagala/fluent-assertions-fluently-assert-the-result-of-net-tests-2nie
  199. https://docs.automapper.org/en/stable/Getting-started.html
  200. https://automapper.org/
  201. https://www.infoq.com/news/2010/02/automapper-rtw/
  202. https://docs.automapper.org/en/latest/15.0-Upgrade-Guide.html
  203. https://docs.automapper.org/en/stable/Configuration-validation.html
  204. https://github.com/LuckyPennySoftware/AutoMapper/releases/tag/v15.0.0
  205. https://www.nuget.org/packages/AutoMapper/15.1.0
  206. https://docs.automapper.org/en/stable/Configuration.html
  207. https://lostechies.com/jimmybogard/2016/06/24/automapper-5-0-speed-increases/
  208. https://stackoverflow.com/questions/38619574/automapper-performance
  209. https://docs.automapper.org/en/stable/Dependency-injection.html
  210. https://serilog.net/
  211. https://github.com/serilog/serilog
  212. https://nblumhardt.com/2023/05/serilog-3-update/
  213. https://github.com/serilog/serilog/releases
  214. https://github.com/serilog/serilog/wiki/Configuration-Basics
  215. https://github.com/serilog/serilog/wiki/Provided-Sinks
  216. https://benfoster.io/blog/serilog-best-practices/
  217. https://www.darylcumbo.net/serilog-vs-nlog-benchmarks/
  218. https://last9.io/blog/serilog-and-opentelemetry/
  219. https://devblogs.microsoft.com/dotnet/monitoring-and-observability-in-cloud-native-asp-net-core-apps/
  220. https://github.com/App-vNext/Polly
  221. https://www.pollydocs.org/
  222. https://learn.microsoft.com/en-us/dotnet/architecture/microservices/implement-resilient-applications/implement-http-call-retries-exponential-backoff-polly
  223. https://www.infoq.com/news/2023/11/Polly-v8/
  224. https://www.nuget.org/packages/Polly/1.0.0
  225. https://www.nuget.org/packages/polly/
  226. https://www.pollydocs.org/advanced/performance.html
  227. https://github.com/App-vNext/Polly/tree/main/samples
Add your contribution
Related Hubs
User Avatar
No comments yet.