Aspnet Core
Lộ trình phát triển toàn diện Aspnet Core theo tiêu chuẩn quốc tế nilbuild/developer-roadmap
Hướng dẫn từng bước từ nền tảng đến chuyên sâu giúp bạn làm chủ Aspnet Core. Tích hợp tài liệu lý thuyết, bài viết thực chiến, video tham khảo và bài tập lập trình trực tiếp trên IDE.
Nền Tảng & Khái Niệm Cốt Lõi
Giai đoạn 1 tập trung hoàn thiện 30 chủ đề then chốt.
ActiveMQ
ActiveMQ is an open-source, multi-protocol message broker that facilitates communication between distributed services by acting as a middleman for data exchange. It enables applications to send and receive messages asynchronously, ensuring that services remain decoupled and resilient even when one system is temporarily unavailable. By supporting industry-standard protocols like AMQP and STOMP, it allows different components of a microservices architecture to share information reliably across various environments.
API Clients and Communication
API clients in ASP.NET Core are components used to send HTTP requests to external web services and receive responses. The framework provides the `IHttpClientFactory` to manage the lifetime and configuration of `HttpClient` instances, which helps prevent socket exhaustion and DNS issues. Developers use these tools to consume RESTful endpoints, handle serialization of JSON data, and manage cross-service communication within a distributed application architecture.
App Settings and Configurations
App settings and configurations provide a way to manage environment-specific variables and application parameters outside of the compiled code. ASP.NET Core uses a centralized configuration system that aggregates data from multiple sources such as JSON files, environment variables, command-line arguments, and user secrets. This approach allows developers to easily switch settings between development, staging, and production environments without modifying the source code.
Basics of ASP.NET Core
[ASP.NET](http://ASP.NET) Core is a open-source, cross-platform web framework for building modern web applications using .NET. Some of the basics of [ASP.NET](http://ASP.NET) Core are Cross-platform, Open-source, Modular, High performance, MVC pattern, Dependency Injection, Middleware, Razor Pages and Razor Components, EF Core.
AutoFac
AutoFac is an inversion of control container for .NET applications that manages the dependencies between classes. It facilitates the loose coupling of components by automatically resolving and injecting required services into constructors or properties. Developers use AutoFac to configure complex object lifetimes, scan assemblies for registrations, and manage modular application structures more efficiently than the built-in ASP.NET Core container.
AutoFixture
AutoFixture is an open-source .NET library designed to minimize the 'Arrange' phase of your unit tests by creating object instances automatically with dummy data. It helps reduce boilerplate code and makes tests easier to maintain.
AutoMapper
AutoMapper is an object-to-object mapping library that eliminates the need for manual code when transforming one type of object into another. It works by using a convention-based approach to match properties between a source object and a destination object, which simplifies the process of flattening complex models into simpler Data Transfer Objects (DTOs). By automating the mapping logic, it reduces repetitive code and keeps the separation between domain models and external-facing representations clean.
Azure Pipelines
Azure Pipelines is a cloud-based service that allows you to automatically build, test, and deploy your ASP.NET Core applications to any platform or cloud provider. It uses YAML configuration files to define continuous integration and continuous deployment workflows, which trigger automatically whenever you push code to your repository. This process automates the steps of compiling your code, running unit tests, and packaging your application into artifacts ready for deployment.
Azure Service Bus
Azure Service Bus is a scalable and reliable messaging platform that can handle a high volume of messages, it's also easy to use, has a lot of features like subscription, Topics, Dead Letter, and easy to integrate with other Azure services, and it's a managed service which means Microsoft takes care of the infrastructure and scaling. However, it's worth noting that Azure Service Bus is a paid service and the cost will depend on the number of messages and the size of the data that you are sending and receiving.
BenchmarkDotNet
BenchmarkDotNet is an open-source library for .NET that provides a simple and easy-to-use API for benchmarking the performance of code. It allows you to measure the performance of methods, classes, and entire assemblies, and provides a rich set of features for analyzing and comparing the results. It provides a wide range of performance metrics, such as CPU cycles, memory allocation, and garbage collection, and can generate detailed reports that include charts, tables, and source code highlighting. It has support for multithreading and a built-in support for .NET Core.
Blazor
Blazor is a web framework that allows developers to build interactive web user interfaces using C# instead of JavaScript. It runs .NET code directly in the browser via WebAssembly or handles UI updates on the server through a real-time connection. Because it shares the same language and libraries across both the client and server, developers can reuse their existing .NET code and business logic throughout the entire application.
Bogus
Bogus is a simple, C#-friendly fake data generator. It lets you create realistic mock objects, lists, and data sets with a fluent API, making it easy to seed tests and demo applications with believable data.
C#
C# is a modern coding language that was developed by Microsoft that focuses on applying the coding style to C++ and making it so that way it's more condensed and simple. It's similar to Java by both being static, strong, and manifestive languages. Both use the System's prebuilt class to do certain features like printing output to the screen, etc.C#, like Java, also contains a garbage collection, which removes lower-level maintenance code from the programmer.
Caching
Caching is a technique of storing frequently used data or information in a local memory, for a certain time period. So, next time, when the client requests the same information, instead of retrieving the information from the database, it will give the information from the local memory. The main advantage of caching is that it improves the performance by reducing the processing burden.
Cassandra
Apache Cassandra is a distributed NoSQL database designed to handle large amounts of data across many commodity servers while providing high availability with no single point of failure. In an ASP.NET Core environment, it is typically accessed using the DataStax C# Driver, which allows developers to execute CQL (Cassandra Query Language) statements to read and write data. This database structure is particularly effective for managing massive datasets that require fast write speeds and horizontal scalability across multiple data centers.
Change Tracker API
The Change Tracker API is a feature within Entity Framework Core that monitors the state of entities loaded into the application's memory. It automatically detects modifications, additions, and deletions made to objects, keeping track of their current values compared to their original state. This mechanism allows the framework to determine which specific updates need to be synchronized with the database when the SaveChanges method is invoked.
CI/CD
CI/CD stands for Continuous Integration and Continuous Deployment, representing a set of practices that automate the process of building, testing, and delivering software. Continuous Integration involves developers frequently merging their code changes into a central repository where automated builds and tests are executed to detect errors early. Continuous Deployment automates the release of these validated changes directly to production environments, allowing teams to deliver new features and bug fixes to users rapidly and reliably.
CircleCI
CircleCI is a cloud-based continuous integration and continuous delivery platform that automates the building, testing, and deployment processes for software applications. It utilizes configuration files defined in YAML to manage workflows, allowing developers to execute automated tests and push builds to various environments whenever code changes are committed to a repository. The platform integrates directly with version control systems like GitHub or GitLab to provide feedback loops and streamline the delivery pipeline for ASP.NET Core projects.
Cloud Databases in ASP.NET Core
Cloud databases are managed database services hosted on platforms like Azure, AWS, or Google Cloud that allow ASP.NET Core applications to store, retrieve, and manage data without maintaining on-premises physical servers. These services provide features such as automated backups, high availability, and horizontal scaling to handle varying workloads. Developers integrate these databases into their applications using connection strings and Entity Framework Core, which acts as an abstraction layer to communicate with cloud-based providers like Azure SQL Database, Cosmos DB, or PostgreSQL.
Code First and Migrations in Entity Framework Core
Code First is a development approach where you define your application's data models as C# classes, and Entity Framework Core generates the corresponding database schema from those classes. Migrations serve as a version control system for your database, tracking changes made to your C# models over time. When you modify your classes, you create a migration file that captures the difference between the current state of your code and the previous database structure. These migration files are then applied to the database to ensure the schema remains synchronized with the application code.
Constraints
Constraints are rules applied to columns in a database table to limit the type of data that can be inserted, ensuring accuracy and reliability. Common examples include Primary Keys, which uniquely identify each record, Foreign Keys, which maintain relationships between tables, and Unique constraints, which prevent duplicate values in a column. Additionally, Not Null constraints ensure that a field must contain a value, while Check constraints enforce specific logical conditions on the data. These rules are managed within the database schema to maintain the integrity of the information stored in the application.
Coravel
Coravel is a library that provides a fluent and easy-to-use syntax for handling common application tasks within ASP.NET Core, such as task scheduling, queuing, and background processing. It acts as a lightweight wrapper around native .NET features, allowing developers to manage complex background operations without needing to configure external dependencies or complex infrastructure. By using its built-in service provider, you can define recurring tasks and event-driven processes directly within your application code.
Cosmos DB
Azure Cosmos DB is a fully managed, NoSQL database service designed for high availability and low-latency access to data at any scale. It supports multiple data models, including document, key-value, graph, and column-family, allowing developers to choose the structure that best fits their application needs. Within ASP.NET Core, it integrates seamlessly through the Azure Cosmos DB .NET SDK, enabling efficient storage, retrieval, and querying of JSON documents in a globally distributed environment.
CouchDB
CouchDB is an open-source, document-oriented NoSQL database that stores data in JSON format. It is designed to be highly available and handles data synchronization across multiple servers or devices using a master-master replication model. Interactions with the database occur through a RESTful HTTP API, allowing developers to perform CRUD operations using standard web requests. Because it is schema-free, it provides the flexibility to store complex, hierarchical data structures that can evolve over time without requiring extensive database migrations.
Cypress
Cypress is an open-source end-to-end testing framework for web applications, it's built on top of JavaScript and provides a set of APIs that allows developers to automate browser interactions. It's commonly used for testing web applications, as it can be used to automate browser-based tests and assert that the application behaves as expected. Cypress for .NET is not built on top of the .NET Core runtime and it does not provide bindings for C# or any other .NET languages, it's built on top of JavaScript and can be run in the browser.
Dapper
Dapper is a lightweight, open-source object-relational mapper for .NET that acts as a thin wrapper over the ADO.NET `IDbConnection` interface. It maps database query results directly to plain old CLR objects by executing raw SQL statements provided by the developer. This tool focuses on high performance and minimal overhead by avoiding the complex abstraction layers found in full-featured ORMs.
Dapr
Dapr (Distributed Application Runtime) is an open-source, portable runtime that makes it easy to build microservices-based applications that run on the cloud and edge. It provides a set of building blocks for building microservices, including service discovery, state management, pub-sub messaging, and more. It is designed to be language-agnostic, so it can be used with any programming language, including .NET.
Data Structures
As the name indicates, a **Data Structure** is a way of organizing the data in the **memory** so it can be used efficiently. Some common data structures are array, linked list, stack, hashtable, queue, tree, heap, and graph.
Database design basics
Database Design is a collection of processes that facilitate the designing, development, implementation and maintenance of enterprise data management systems. Properly designed database are easy to maintain, improves data consistency and are cost effective in terms of disk storage space. The main objectives of database design in DBMS are to produce logical and physical designs models of the proposed database system.
Database Fundamentals
Database fundamentals involve the core concepts of storing, organizing, and retrieving data within software applications. This includes understanding relational databases, which store data in structured tables, and non-relational databases, which handle unstructured or semi-structured data. Developers interact with these systems using tools like SQL to perform operations such as creating, reading, updating, and deleting records. Mastering these basics ensures data integrity, efficient query performance, and reliable application state management.
Kỹ Năng Trọng Tâm & Thực Hành
Giai đoạn 2 tập trung hoàn thiện 30 chủ đề then chốt.
Databases
Databases in ASP.NET Core serve as persistent storage systems that allow applications to save, retrieve, and manage structured data. Developers typically interact with these systems using Entity Framework Core, an object-relational mapper that bridges the gap between database tables and C# objects. This setup enables applications to perform complex queries and transactions while maintaining a clear separation between the data access layer and the business logic of the application.
Dependency Injection
Dependency Injection is a software design pattern that allows a class to receive its dependencies from an external source rather than creating them internally. In ASP.NET Core, this pattern is built directly into the framework to manage the lifetime and instantiation of services throughout an application. By using this approach, components remain decoupled, making the codebase easier to test, maintain, and scale.
DI Containers
A DI container is a framework component that manages the instantiation and lifetime of objects in an application. It acts as a central registry where you define which implementations should be provided for specific interfaces or base classes. When an application requests a service, the container automatically resolves the dependencies, injects them into the class, and manages their disposal according to the defined service lifetime.
Distributed Cache
A distributed cache is a cache shared by multiple app servers, typically maintained as an external service to the app servers that access it. A distributed cache can improve the performance and scalability of an [ASP.NET](http://ASP.NET) Core app, especially when the app is hosted by a cloud service or a server farm.
Distributed Lock
A distributed lock coordinates access to a shared resource across multiple processes or services. It prevents concurrent modifications and race conditions by ensuring only one client holds the lock at a time, typically backed by a store such as Redis, ZooKeeper, or a database.
Docker
Docker is an open-source platform that automates the deployment of applications inside lightweight, portable containers. It packages an ASP.NET Core application along with its dependencies, libraries, and runtime environment into a single unit to ensure consistent behavior across different computing environments. Developers use Docker to isolate services from one another, making it easier to build, test, and deploy microservices within a distributed architecture.
DynamoDB
DynamoDB is a fully managed, serverless NoSQL database service provided by Amazon Web Services that supports key-value and document data structures. In ASP.NET Core applications, it is used to store and retrieve data with consistent single-digit millisecond latency at any scale. Developers typically interact with this service using the AWS SDK for .NET, which provides a high-level Object Persistence Model or a lower-level document model to perform CRUD operations on tables. Because it is schema-less, it allows for flexible data modeling and automatic scaling of throughput capacity to meet the demands of high-traffic web applications.
EasyNetQ
EasyNetQ is a thin, open-source .NET client library for RabbitMQ that simplifies the process of sending and receiving messages. It provides a high-level API that handles complex tasks like connection management, serialization, and exchange or queue declarations automatically. Developers use it to facilitate asynchronous communication between microservices by abstracting the lower-level details of the RabbitMQ C# driver.
Elasticsearch
Elasticsearch is a distributed, open-source search and analytics engine that can be used to index, search, and analyze large volumes of data quickly and in near real-time. It is built on top of the Apache Lucene library and can be used to perform full-text search, faceted search, and geospatial search, among other things.
Entity Framework 2nd Level Cache
Entity Framework 2nd Level Cache is a caching mechanism that stores the results of database queries in memory to reduce the number of redundant trips to the database. When an application requests data, the system first checks the cache; if the data is already stored there, it retrieves it directly, bypassing the database execution. This process significantly improves application performance and minimizes database load for frequently accessed, read-heavy data.
Entity Framework Core
Entity Framework Core (EF Core) is an open-source Object-Relational Mapping (ORM) framework for .NET. It is a lightweight, cross-platform version of Entity Framework, the ORM framework that was part of the .NET Framework. EF Core allows developers to work with relational data using domain-specific objects, eliminating the need to write raw SQL statements. Instead, EF Core provides a set of APIs that can be used to interact with a database, providing a simple and efficient way to perform common database operations such as querying, inserting, updating, and deleting data.
FakeItEasy
FakeItEasy is a popular mocking library for .NET that allows developers to create fake objects for unit tests with a simple and readable syntax. It simplifies the process of stubbing methods, properties, and events, enabling you to isolate the code being tested from its dependencies. By providing a fluent API, it helps in defining the behavior of objects that are not yet implemented or are difficult to instantiate in a test environment.
Filters and Attributes
In the [ASP.NET](http://ASP.NET) Core framework, filters and attributes are used to add additional functionality to controllers and action methods, such as authentication, authorization, caching, and exception handling.
FluentValidation
FluentValidation is an open-source library for .NET that provides a fluent, easy-to-use API for validating domain models. It allows developers to define validation rules using a fluent, chainable syntax. It separates validation rules into separate classes called validators, it supports async validation, custom validation rules, and cascading validation. It makes it easy to read and understand the validation logic, and it returns a ValidationResult object, which contains information about any validation errors that were found.
Fluid
Fluid is an open-source template engine for .NET that serves as a .NET implementation of the Liquid template language. It allows developers to create and render text-based templates that are secure, portable, and independent of the underlying application logic. By parsing templates into an abstract syntax tree, it enables efficient execution and provides a sandboxed environment to prevent unauthorized access to sensitive system data during the rendering process.
Entity Framework Core Framework Basics
Entity Framework Core is a lightweight, extensible, and cross-platform version of the popular Entity Framework data access technology. It acts as an object-database mapper that enables .NET developers to work with a database using .NET objects. This framework eliminates the need for most of the data-access code that developers usually need to write, allowing them to perform database operations through strongly-typed LINQ queries.
Frameworks
.NET offers a range of frameworks built on the base runtime, each addressing a specific domain: [ASP.NET](http://ASP.NET) Core for web applications and APIs, EF Core for data access, and .NET MAUI for cross-platform client apps. Choosing the right framework for the job is one of the first decisions when starting a new .NET project.
General Development Skills
General development skills represent the foundational knowledge and practices that enable a programmer to write, maintain, and troubleshoot software effectively. These skills include proficiency in version control systems like Git, a solid understanding of data structures and algorithms, and the ability to apply clean coding principles such as SOLID and DRY. Mastery of these fundamentals allows developers to work efficiently within team environments, manage complex codebases, and bridge the gap between architectural concepts and functional code.
Git
[Git](https://git-scm.com/) is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency.
GitHub Actions
GitHub Actions is a continuous integration and continuous deployment platform that allows developers to automate their software workflows directly within a GitHub repository. It enables the creation of automated pipelines that build, test, and deploy ASP.NET Core applications whenever code changes are pushed. These workflows are defined using YAML files, which trigger specific tasks such as compiling the source code, running unit tests, and publishing artifacts to cloud environments like Azure or AWS.
Repo Hosting Services
There are different repository hosting services with the most famous one being GitHub, GitLab and BitBucket. I would recommend creating an account on GitHub because that is where most of the OpenSource work is done and most of the developers are.
GitLab CI/CD
GitLab CI/CD is the continuous integration and delivery tooling built into GitLab. Pipelines are defined in a `.gitlab-ci.yml` file, where jobs run on GitLab runners to build, test, and deploy your application automatically on every change.
GraphQL .NET
GraphQL is a query language for your API, it allows clients to define the structure of the data they need, and the server will return only the requested data. It is an alternative to RESTful web services, and it is gaining popularity because of its flexibility and efficiency.
GraphQL
GraphQL is a query language for APIs that allows clients to request exactly the data they need from a server. It provides a structured approach to data fetching by using a single endpoint and a strongly-typed schema to define the available capabilities. This technology enables developers to combine multiple data sources into a unified interface, which prevents the problems of over-fetching or under-fetching information.
Gridify
Gridify offers a powerful string-based dynamic LINQ query language that is both simple and easy to use. Gridify is a dynamic LINQ library that simplifies the process of converting strings to LINQ queries. Gridify makes it effortless to apply filtering, sorting, and pagination using text-based data. It also has a Javascript/Typescript client to integrate the Gridify with the frontend tables.
gRPC
gRPC is a high-performance, open-source framework that uses HTTP/2 for transport and Protocol Buffers as a message format to enable communication between services. It allows a client application to directly call a method on a server application located on a different machine as if it were a local object. This technology is designed for low-latency, high-throughput communication, making it suitable for internal microservices and real-time streaming data.
Hangfire
Hangfire is an open-source library that allows developers to create, process, and manage background jobs in .NET applications. It provides a persistent storage mechanism that ensures tasks are executed reliably even if the application restarts. The library features a built-in dashboard for monitoring job progress, retrying failed tasks, and scheduling recurring operations without requiring a separate Windows Service or external task scheduler.
HotChocolate
HotChocolate is a feature-rich, open-source GraphQL server framework for .NET that enables developers to build flexible APIs. It provides tools to define schemas, resolve data, and execute queries by sitting between your client applications and your underlying data sources. The framework integrates seamlessly with the ASP.NET Core ecosystem, allowing you to expose existing business logic as a strongly typed graph while supporting advanced capabilities like subscriptions, data loaders, and schema stitching.
HTTP / HTTPS Protocol
HTTP (Hypertext Transfer Protocol) is the foundational set of rules used for transmitting data across the internet, enabling communication between web browsers and servers. It functions as a request-response protocol where a client sends a request to a server, and the server returns a response containing the requested resource or status information. HTTPS (Hypertext Transfer Protocol Secure) is the encrypted version of this protocol, which incorporates TLS (Transport Layer Security) to protect data integrity and privacy by ensuring that information exchanged between the client and server remains secure from unauthorized interception.
Kafka
Kafka is a distributed event streaming platform used to handle high-throughput data feeds and enable communication between decoupled services. It functions as a publish-subscribe messaging system where producers send records to topics and consumers read those records asynchronously. In an ASP.NET Core environment, it serves as a robust backbone for event-driven architectures, allowing different microservices to exchange messages reliably without being directly connected to one another.
Kiến Trúc Nâng Cao & Tối Ưu
Giai đoạn 3 tập trung hoàn thiện 30 chủ đề then chốt.
Kubernetes
Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. It organizes containers into logical units called pods and ensures they are running across a cluster of machines according to desired configurations. The system handles tasks such as load balancing, service discovery, and self-healing to maintain the availability and performance of applications. By managing these infrastructure requirements, it allows developers to focus on the continuous delivery and scaling of microservices within a distributed environment.
Lazy, Eager, and Explicit Loading
Loading patterns in Entity Framework Core determine how and when related data is retrieved from the database when querying a primary entity. Eager loading fetches related data immediately as part of the initial query using the `Include` method. Lazy loading automatically retrieves related data from the database only at the moment a navigation property is accessed in the code. Explicit loading allows developers to manually trigger the retrieval of related data for an entity that has already been loaded, typically using the `Entry` API. Each approach offers a different trade-off between database round-trips and the amount of data transferred, allowing developers to optimize application performance based on specific data access requirements.
C# Basics
C# is a modern, object-oriented programming language developed by Microsoft that serves as the primary language for building applications on the .NET platform. It provides a comprehensive set of features, including strong typing, type safety, and robust memory management, which allow developers to write efficient and maintainable code. Learning C# involves understanding core concepts such as variables, data types, control structures, classes, and namespaces. Mastery of these fundamentals is necessary to effectively structure logic and interact with the various libraries provided by the ASP.NET Core framework.
Dependency Injection Life Cycles
Dependency Injection life cycles define how and when the container creates and disposes of service instances within an application. There are three primary lifetimes: Transient, which creates a new instance every time a service is requested; Scoped, which creates a single instance for the duration of a single client request; and Singleton, which creates a single shared instance the first time it is requested and uses that same instance for every subsequent request throughout the application's lifetime.
LightBDD
LightBDD is a framework designed to support Behavior-Driven Development in .NET applications by providing a way to write human-readable test scenarios. It allows developers to define requirements and expectations using structured, descriptive steps that can be mapped directly to automated code execution. By integrating into the testing workflow, it produces detailed reports that bridge the communication gap between technical stakeholders and non-technical team members.
LiteDB
LiteDB is a serverless, single-file NoSQL database engine written in .NET C#. It stores data in a BSON format, making it easy to manage document-based collections directly within an application without needing to install or configure an external database server. It provides a lightweight solution for small-scale projects, desktop applications, or mobile apps that require local data persistence with a simple API.
Log Frameworks
Log frameworks in ASP.NET Core provide a structured way to record application events, errors, and diagnostic information to various destinations such as the console, files, or cloud-based monitoring services. They integrate with the built-in `ILogger` abstraction, allowing developers to capture runtime data and filter messages based on severity levels like Information, Warning, or Error. These tools help maintain application health by ensuring developers can track execution flows and troubleshoot issues efficiently in production environments.
Manual Mapping
Manual mapping is the process of explicitly transferring data from one object to another by assigning properties individually within your code. Developers achieve this by creating a new instance of a destination object and setting its fields using the corresponding values from a source object. This approach offers full control over the transformation logic, allowing for specific adjustments, conditional logic, or data formatting during the copy process. Because it relies on standard code without external dependencies, it remains highly performant and easy to debug for simple data structures.
Mapperly
Mapperly is a source generator for .NET that maps objects without runtime reflection. It generates the mapping code at compile time, making it fast and keeping mappings in sync with your models — just declare a mapper class and it takes care of the rest.
MariaDB
MariaDB is a community-developed, open-source relational database management system that serves as a binary-compatible drop-in replacement for MySQL. It uses structured query language to store, manage, and retrieve data within tables, maintaining a high level of performance and reliability. ASP.NET Core applications interact with MariaDB using connectors or Object-Relational Mappers like Entity Framework Core to execute database operations and manage data persistence.
Marten
Marten is a .NET document database library built on PostgreSQL. It turns PostgreSQL into a document store, letting you persist and query .NET objects as JSON documents while still leveraging SQL features such as indexes, transactions, and native Postgres tooling.
MassTransit
MassTransit is a free, open-source distributed application framework for .NET that simplifies the process of creating message-based applications. It acts as an abstraction layer over various message brokers, such as RabbitMQ or Azure Service Bus, allowing developers to focus on application logic rather than the underlying infrastructure. By providing built-in patterns for messaging, such as publish/subscribe, request/response, and routing, it helps manage complex communication between services in a distributed system.
MediatR
MediatR is an open-source library for .NET that is designed to simplify the process of handling messages and commands in a clean, decoupled manner. It's particularly useful in applications that use the Command-Query Responsibility Segregation (CQRS) pattern and event-driven architecture. It provides a simple and easy-to-use API for handling messages, and supports the concept of pipelines, which allow you to add additional behavior to message handling, such as logging, validation, and exception handling.
Memcached
Memcached is an open-source, high-performance, distributed memory object caching system which helps in reducing database load. It maintains data as an in-memory key-value store for small chunks of arbitrary data (strings, objects) which can be result of API calls, database reads and so on.
Memory Cache
Memory caching (often simply referred to as caching) is a technique in which computer applications temporarily store data in a computer’s main memory (i.e., random access memory, or RAM) to enable fast retrievals of that data. The RAM that is used for the temporary storage is known as the cache.
Microservices
Microservices is an architectural style that structures an application as a collection of small, autonomous services modeled around specific business domains. In ASP.NET Core, each service runs as an independent process and communicates through lightweight protocols like HTTP/REST, gRPC, or message brokers. This approach allows developers to build, deploy, and scale individual components of an application separately, which increases overall system flexibility and development velocity.
Microsoft.Extensions.DependencyInjection
Microsoft.Extensions.DependencyInjection is the built-in library provided by .NET that implements the dependency injection pattern. It acts as a lightweight container that manages the creation and lifetime of objects within an application. This tool allows developers to register services in a central location, which are then automatically injected into classes as needed through their constructors.
Middlewares
Middleware is a component that is assembled into an application pipeline to handle HTTP requests and responses. Each component in the pipeline decides whether to pass the request to the next component or perform actions before and after the next component is invoked. These components are executed in the order they are added to the pipeline, allowing developers to manage tasks such as authentication, logging, and routing efficiently.
Minimal APIs
Minimal APIs are a lightweight architectural approach for building HTTP APIs in ASP.NET Core with minimal files, dependencies, and configuration. Instead of requiring complex controller classes, this design allows developers to define endpoints directly within the application's configuration file using simple lambda expressions or method groups. This pattern reduces boilerplate code, making it an efficient choice for creating small, high-performance microservices and cloud-native applications.
MongoDB
MongoDB is a document-oriented NoSQL database that stores data in flexible, JSON-like documents rather than traditional tables and rows. In an ASP.NET Core environment, developers interact with MongoDB using the official C# driver, which allows for storing complex data structures that can evolve over time without requiring rigid schema migrations. This database provides high scalability and performance, making it a suitable choice for applications that handle large volumes of unstructured or semi-structured data.
Moq
Moq is a popular mocking library for .NET that allows developers to simulate the behavior of complex objects and interfaces during unit testing. It provides a simple API to create "mock" versions of dependencies, enabling you to define specific return values for methods or verify that certain interactions occurred within your code. By isolating the component under test from its external dependencies, Moq ensures that tests focus solely on the logic being verified.
MSTest
MSTest is a unit testing framework for the .NET framework, it's one of the built-in test frameworks in Visual Studio and it's widely used for unit testing in the .NET ecosystem. In the context of [ASP.NET](http://ASP.NET), MSTest can be used to write unit tests for web applications built using the [ASP.NET](http://ASP.NET) framework. MSTest provides features such as data-driven testing, parallel test execution, and test discovery and execution, it also provides the ability to run tests on multiple frameworks.
MVC
MVC is an architectural pattern that separates an application into three main components: Models, Views, and Controllers. The Model manages the data and business logic of the application, the View handles the visual representation and user interface, and the Controller processes incoming requests, interacts with the Model, and selects the appropriate View to display to the user. This separation of concerns allows developers to build more organized, maintainable, and testable web applications.
MySQL
MySQL is an open-source relational database management system that organizes data into tables with predefined relationships. In an ASP.NET Core environment, it serves as a robust backend storage solution accessed through Entity Framework Core or direct database drivers. It uses Structured Query Language to manage, retrieve, and manipulate data efficiently while ensuring consistency and reliability for web applications.
Native Background Service
A Native Background Service is a class in ASP.NET Core that implements the `IHostedService` interface or inherits from the `BackgroundService` base class to execute long-running tasks in the background. These services run independently of the request-response cycle, allowing the application to perform periodic operations like data cleanup, message queue processing, or scheduled report generation. The framework manages the lifecycle of these services, ensuring they start when the application host begins and shut down gracefully when the host stops.
.NET Aspire
.NET Aspire is an opinionated stack for building observable, production-ready cloud-native .NET applications. It provides curated packages for common cloud dependencies, service discovery, orchestration for local development, and built-in telemetry to make distributed applications easier to build and debug.
.NET Aspire
.NET Aspire is an opinionated stack for building observable, production-ready cloud-native .NET applications. It provides curated packages for common cloud dependencies, service discovery, orchestration for local development, and built-in telemetry to make distributed applications easier to build and debug.
.NET CLI
.NET CLI is the command-line interface (CLI) for the .NET platform. It is a tool that provides a common interface for running .NET Core command-line tools and utilities. .NET Core is a cross-platform, open-source, and modular version of the .NET framework, and the .NET CLI provides a way to interact with it from the command line.
.NET MAUI
.NET MAUI (Multi-platform App UI) is the cross-platform UI framework for .NET. It lets you build native Android, iOS, macOS, and Windows applications from a single C# and XAML codebase, sharing business logic while still allowing per-platform customizations when needed.
.NET Framework
.NET (pronounced "dot net") is a software framework developed by Microsoft that can be used to create a wide range of applications, including Windows desktop and web applications, mobile apps, and gaming. The .NET Framework provides a large library of pre-built functionality, including collections, file input/output, and networking, that can be used by .NET applications. It also includes a Common Language Runtime (CLR) which manages the execution of code, providing features such as memory management, security, and exception handling.
Hệ Sinh Thái & Triển Khai Thực Tế
Giai đoạn 4 tập trung hoàn thiện 30 chủ đề then chốt.
NetMQ
NetMQ is a lightweight, high-performance messaging library that serves as a native C# port of the ZeroMQ library. It enables developers to implement various messaging patterns, such as request-reply, pub-sub, and push-pull, for communication between distributed services. By utilizing asynchronous message queues, it allows microservices to exchange data efficiently across different processes or network nodes without relying on a dedicated message broker server.
NHibernate
NHibernate is an object-relational mapping (ORM) framework for .NET that facilitates the interaction between a relational database and object-oriented code. It enables developers to map .NET classes to database tables and map properties to table columns, allowing data to be queried and manipulated using object-oriented principles. By automating the generation of SQL commands, it minimizes the need for manual data access code and simplifies complex database operations within an application.
NLog
NLog is a flexible and free logging platform for various .NET platforms, including ASP.NET Core. It allows developers to route log messages to multiple destinations, such as files, databases, or cloud services, based on configurable rules. By using a centralized configuration file, it enables fine-grained control over log levels and output formats without requiring changes to the application code.
NoSQL Databases
NoSQL databases are non-relational data management systems that store information in flexible formats such as documents, key-value pairs, graphs, or wide-column stores rather than traditional tables. These databases provide a schema-less approach to data storage, allowing developers to handle unstructured or rapidly evolving datasets with high horizontal scalability. In ASP.NET Core applications, these databases are often utilized to manage high-velocity data or complex hierarchical objects that do not fit well into a rigid relational structure.
NServiceBus
NServiceBus is a service bus framework for .NET that simplifies the process of building distributed systems by managing messaging between decoupled services. It provides a reliable abstraction over messaging transports like RabbitMQ, Azure Service Bus, or Amazon SQS, handling complex tasks such as message retries, transactional consistency, and out-of-the-box support for the Saga pattern. Developers use NServiceBus to ensure that messages are processed reliably even if individual components experience temporary failures or network interruptions.
NSubstitute
NSubstitute is a friendly library for .NET used to create and work with mock objects in unit tests. It provides a simple, concise syntax that allows developers to substitute dependencies, define return values for methods, and verify that specific actions were performed during a test execution.
Nuke
Nuke is a cross-platform build automation system that allows you to define your build processes using C#. It leverages the power of the .NET ecosystem to provide strongly typed build scripts, enabling you to manage complex tasks like compilation, testing, and deployment directly within your IDE. By treating your build configuration as code, it offers full IntelliSense support, easy debugging, and simple integration with various CI/CD pipelines.
NUnit
NUnit is an open-source unit testing framework for the .NET ecosystem that allows developers to write and execute tests to ensure individual sections of code function as intended. It provides a rich set of assertions and attributes that help structure test suites, manage setup and teardown processes, and handle various test scenarios. By integrating seamlessly with the .NET CLI and Visual Studio, it enables automated verification of application logic during the development lifecycle.
Object Mapping
Object mapping is the process of automatically converting data from one object type to another, typically between domain models and data transfer objects (DTOs). It streamlines the development process by eliminating the need to write repetitive manual assignment code when moving data between different layers of an application. Libraries like AutoMapper are frequently integrated into ASP.NET Core projects to handle these transformations efficiently, ensuring that complex object structures remain synchronized across various parts of the system.
ORM
ORM stands for Object-Relational Mapping, and it is a technique that allows a developer to work with a database using objects. It is a way of abstracting the database so that the developer can think in terms of objects, rather than tables and SQL queries. This can make it easier to write and maintain code, as well as improve the performance of the application.
Ocelot
Ocelot is an open-source API gateway designed for ASP.NET Core applications that acts as a single entry point for a microservices architecture. It functions as a reverse proxy that receives incoming HTTP requests and routes them to the appropriate downstream services based on predefined configuration. This tool handles essential cross-cutting concerns such as request aggregation, authentication, authorization, rate limiting, and caching, allowing developers to centralize service management rather than implementing these features in every individual
OData
OData is an open protocol that allows for the creation and consumption of queryable and interoperable RESTful APIs. It provides a standardized way to define the data model and the query syntax, enabling clients to request specific data using URL parameters for filtering, sorting, pagination, and selecting properties. By integrating with ASP.NET Core, it simplifies the development of data-driven services that support complex querying capabilities without requiring custom code for every filtering scenario.
Orleans
Orleans is a cross-platform framework for building robust, scalable distributed applications in .NET. It simplifies the development process by using a virtual actor model that allows developers to create stateful, distributed objects without needing to manage complex concurrency, persistence, or messaging concerns manually. The runtime automatically handles the lifecycle, placement, and activation of these objects across a cluster of servers, making it well-suited for high-throughput systems like gaming backends, real-time analytics, and chat applications.
Playwright
Playwright is an open-source library for automating web browsers built by Microsoft, similar to Selenium, it's commonly used for testing web applications. It's built on top of the .NET Core runtime and it provides bindings for C#, it allows developers to write tests for web applications in C# or other .NET languages. Playwright is designed to be fast and reliable and allows developers to run tests in multiple browsers.
Polly
Polly is a .NET resilience and transient-fault-handling library that allows developers to express policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner. It helps manage instability in external services by defining how an application should react when a network request fails or a system resource becomes unresponsive. By integrating these policies, applications can maintain stability and gracefully handle failures during remote service communication.
PostgreSQL
PostgreSQL is an open-source, object-relational database management system known for its reliability, feature robustness, and performance. Within the ASP.NET Core ecosystem, it serves as a powerful storage backend that integrates seamlessly with Entity Framework Core to handle complex data relationships and transactions. Developers often utilize the Npgsql provider to establish a direct connection between their applications and the database, allowing for efficient data querying, schema management, and persistent storage of structured information.
Puppeteer
Puppeteer is an open-source library for automating web browsers, similar to Selenium and Playwright. It's built on top of the Chrome DevTools protocol and it provides a set of APIs that allows developers to interact with web browsers and simulate user interactions, such as clicking buttons, filling out forms, and navigating between pages. It's commonly used for testing web applications, web scraping, and generating screenshots and PDFs of web pages. Puppeteer for .NET is built on top of the .NET Core runtime and it provides bindings for C# and allows developers to write tests for web applications in C# or other .NET languages.
Quartz
Quartz is an open-source job scheduling library that allows developers to integrate sophisticated task scheduling into their applications. It enables the execution of background jobs based on complex triggers, such as specific times, recurring intervals, or cron
RabbitMQ
RabbitMQ is an open-source message broker that acts as a middleware for services to communicate asynchronously by sending and receiving messages. In an ASP.NET Core microservices architecture, it enables decoupled communication by allowing one service to place a message into a queue without needing an immediate response from the receiver. It supports various messaging patterns, including publish/subscribe and request/reply, which helps ensure system reliability and scalability during periods of high traffic.
Razor Components
Razor Components are the fundamental building blocks of user interfaces in Blazor applications. They are reusable units that combine HTML markup with C# code to define how a part of a webpage should render and behave. These components are stored as files with a .razor extension and use a syntax that allows developers to integrate logic directly within the UI layout, enabling dynamic updates and event handling within the browser.
Razor Pages
Razor Pages is a page-focused framework within ASP.NET Core that simplifies the process of building dynamic web interfaces by combining HTML with C# code. It uses a file-based routing system where each page consists of a `.cshtml` file for the view and a `.cshtml.cs` file for the page model, which handles the logic for handling requests and processing data. This approach keeps the code associated with a specific UI component bundled together, making it easier to manage and develop individual pages compared to the traditional Model-View-Controller pattern.
Razor
Razor is a markup syntax that allows developers to embed server-based code into web pages using C#. It enables the seamless integration of dynamic programming logic directly within HTML, which the server processes to generate the final output sent to the browser. This syntax simplifies the creation of web content by minimizing the amount of code required to transition between static markup and executable server-side instructions.
Real-Time Communication
Real-time communication in ASP.NET Core is primarily handled through SignalR, a library that allows server-side code to push content to connected clients instantly. It facilitates bi-directional communication between the server and the browser, enabling features like live notifications, chat applications, and real-time data dashboards without requiring the client to constantly request updates.
Redis Distributed Cache
Redis is an open-source, in-memory data store used as a distributed cache to improve the performance and scalability of ASP.NET Core applications. It allows multiple instances of an application to share the same cached data by storing information in a centralized server rather than in the local memory of an individual web server. This approach ensures data consistency across a server farm and prevents the loss of cached information if a specific application instance restarts.
Relational Databases
Relational databases are structured data storage systems that organize information into tables with rows and columns. They use a schema to define the relationship between data points and typically rely on Structured Query Language (SQL) to manage, query, and retrieve that data. In the ASP.NET Core ecosystem, developers frequently interact with these systems using Object-Relational Mapping tools like Entity Framework Core to bridge the gap between relational tables and object-oriented code.
RepoDB
RepoDB is a lightweight, high-performance hybrid Object-Relational Mapper (ORM) for .NET that bridges the gap between micro-ORMs like Dapper and full-featured ORMs like Entity Framework. It allows developers to perform CRUD operations and execute complex SQL queries with minimal overhead while providing the flexibility to write raw SQL when necessary. The library is designed to offer a balance of speed and developer productivity by automating common database tasks through an easy-to-use extension-based API.
Respawn
Respawn is a small .NET utility for resetting test databases to a clean state. It intelligently deletes data by tracking dependencies between tables, so you can run integration tests quickly without manually managing cleanup between test runs.
REST
REST (Representational State Transfer) is an architectural style for building web services. In the context of .NET, RESTful web services can be created using the [ASP.NET](http://ASP.NET) Web API framework, which allows developers to create HTTP-based services that can be consumed by a wide range of clients, including web browsers and mobile devices. The Web API framework provides a set of tools and libraries for creating RESTful services, including routing, request/response handling, and support for a variety of data formats, such as JSON and XML.
REST
REST, which stands for Representational State Transfer, is an architectural style for designing networked applications that rely on stateless, client-server communication. It uses standard HTTP methods such as GET, POST, PUT, and DELETE to perform operations on resources identified by unique URLs. In ASP.NET Core, developers implement RESTful services by creating controllers that map HTTP verbs to specific data actions, allowing different applications to exchange information in formats like JSON or XML.
Scalar
Scalar is a lightweight API platform for .NET that generates interactive API documentation and a UI for testing endpoints. It integrates with [ASP.NET](http://ASP.NET) Core as a fast, configurable alternative to the default Swagger UI, built on the OpenAPI specification.
Chuyên Gia & Mở Rộng Hệ Thống
Giai đoạn 5 tập trung hoàn thiện 26 chủ đề then chốt.
Scoped Service Lifetime
Scoped services are created once per client request within an ASP.NET Core application. When you register a service with a scoped lifetime, the framework generates a new instance for every individual HTTP request and shares that same instance across all components that process that specific request. This ensures that data remains consistent throughout the entire lifecycle of a single user interaction while preventing the service from persisting across different, unrelated requests.
Scriban
Scriban is a fast, powerful, and safe text templating language and engine for .NET. It allows developers to define dynamic templates that can be parsed and rendered with custom data objects. Because it focuses on security and performance, it is often used for generating emails, reports, or dynamic HTML content within server-side applications.
Scrutor
Scrutor is a library for ASP.NET Core that extends the built-in dependency injection container with additional features, primarily focused on assembly scanning and decorator support. It allows developers to automatically register services based on specific conventions or attributes, which helps reduce the amount of boilerplate code required for manual service configuration. Additionally, it provides a clean syntax for decorating existing services, making it easier to implement cross-cutting concerns like logging or caching without modifying the original implementation classes.
Search Engines
Search engines in ASP.NET Core are specialized tools integrated into applications to provide fast, full-text search capabilities over large datasets. Unlike standard relational databases that primarily focus on structured data retrieval, these engines use indexing techniques to perform complex queries, rank results by relevance, and handle fuzzy matching. Developers typically connect ASP.NET Core applications to dedicated search platforms like Elasticsearch, Azure AI Search, or Meilisearch to improve the speed and efficiency of data discovery for end users.
Serilog
Serilog is a third-party logging library for [ASP.NET](http://ASP.NET) Core that allows developers to easily create structured and searchable log data. It is built on top of the `Microsoft.Extensions.Logging` framework, which is included in [ASP.NET](http://ASP.NET) Core. Serilog provides features such as automatic logging of request and response data, and the ability to write logs to a variety of destinations, including the console, files, and various logging services. It also supports for filtering and formatting log messages.
Shouldly
Shouldly is an assertion library for .NET that focuses on providing human-readable error messages when tests fail. It replaces traditional assertion syntax with a fluent, natural language style, making it easier to understand exactly why a test did not meet your expectations. Instead of generic messages, it generates descriptive output based on the code being tested, which simplifies the debugging process for developers.
SignalR Core
SignalR Core is a library that simplifies the process of adding real-time web functionality to applications by allowing server-side code to push content to connected clients instantly. It automatically manages connection management, such as handling sockets, while falling back to other compatible technologies like Server-Sent Events or Long Polling when necessary. This tool enables developers to create interactive features like live chat, dashboards, and real-time notifications by maintaining persistent connections between the server and the browser.
Singleton
A Singleton service is created the first time it is requested or when the application starts, and the same instance is then shared across every subsequent request throughout the entire application lifetime. Because this single instance persists for the duration of the app, it is commonly used for managing shared state, configuration settings, or caching services that need to maintain data across different parts of the system.
Solr
Solr is an open-source, enterprise-level search platform built on top of the Apache Lucene library. It provides high-performance, full-text search capabilities, hit highlighting, and faceted search features for large-scale applications. Within an ASP.NET Core environment, developers interact with Solr to index and retrieve structured or unstructured data, enabling fast and complex query operations that go beyond the limitations of traditional relational database search functions.
SpecFlow
SpecFlow is a testing framework for .NET that enables Behavior Driven Development by allowing you to define application requirements and acceptance criteria in a human-readable format. It uses the Gherkin syntax, which employs plain language statements like "Given," "When," and "Then" to describe software features and scenarios. These specifications are then mapped to underlying C# code, which executes the tests to verify that the application behaves as expected.
Sphinx
Sphinx is an open-source, full-text search server designed to provide fast and relevant search results for large datasets. It functions as an external indexing engine that allows developers to perform complex searches across databases, XML files, or other data sources without overloading the primary database. By integrating Sphinx into an ASP.NET Core application, developers can implement advanced features like Boolean queries, ranking, and highlighting to handle high-performance search requirements.
SQL Basics
SQL (Structured Query Language) is a standard programming language designed for managing and manipulating data held in relational databases. It allows developers to perform essential operations such as retrieving data with queries, inserting new records, updating existing information, and deleting entries from database tables. By using SQL, applications can interact with database management systems to ensure data is stored, organized, and accessed efficiently.
SQL Server
MS SQL (or Microsoft SQL Server) is the Microsoft developed relational database management system (RDBMS). MS SQL uses the T-SQL (Transact-SQL) query language to interact with the relational databases. There are many different versions and editions available of MS SQL
Steeltoe
Steeltoe is an open-source project that provides a set of libraries for building cloud-native applications on the .NET platform. The libraries are designed to work with the .NET Core runtime and provide a set of abstractions for common cloud-native patterns, such as service discovery, configuration management, and circuit breaking. The goal of Steeltoe is to make it easy for developers to take advantage of the cloud-native capabilities of the .NET platform and build resilient and scalable applications.
Stored Procedures
Stored procedures are prepared collections of SQL statements that are stored within a database to be executed as a single unit. When working with ASP.NET Core, these procedures allow developers to encapsulate complex logic and multiple queries on the database server side, which helps reduce the amount of data transferred between the application and the database. They are invoked by the application using command objects or Object-Relational Mapping tools like Entity Framework Core, providing a way to handle data operations securely and efficiently.
StyleCop Rules
StyleCop is a tool used for developers to standardize their code and ensure they all follow the same syntax principles. With StyleCop, one standard can be defined in a `stylecop.json` file and shared across your team so that each member has the same guidelines when formatting your code. Beyond a single project, StyleCop can also be added as an extension, so all of the projects on your IDE follow the same formatting rules, this is especially useful if your organization follows the same rule standards for all projects.
Task Scheduling
Task scheduling in ASP.NET Core involves executing background operations at specific intervals or at designated times without requiring direct user interaction. This functionality is typically implemented using the `IHostedService` interface or the `BackgroundService` base class, which allow developers to run long-running processes within the application's lifecycle. These background tasks are useful for performing recurring operations such as sending automated emails, cleaning up databases, or synchronizing external data sources.
Template Engines
Template engines in [ASP.NET](http://ASP.NET) are libraries that allow developers to embed dynamic data in HTML templates. These engines are used to separate the logic of the application from the presentation of the data, making it easy to change the appearance of the application without having to change the underlying code.
Test Containers
Testcontainers is a library that runs throwaway Docker containers for your tests. The .NET version lets you spin up real instances of databases, message brokers, and other services inside integration tests, then disposes of them automatically when the tests finish.
Testing
Testing in ASP.NET Core involves verifying that your application components function correctly and meet the specified requirements. Developers use various approaches such as unit testing to validate individual methods or classes, integration testing to ensure different modules work together seamlessly, and functional testing to evaluate the application from the user's perspective. These processes utilize testing frameworks like xUnit, NUnit, or MSTest along with built-in tools to automate the validation of business logic, database interactions, and API endpoints to maintain code reliability.
Transient
Transient services are created every time they are requested from the service container. This lifecycle is ideal for lightweight, stateless services because a new instance is provided for every controller or service that requires it. Since these objects are not shared across different parts of the application, they avoid issues related to shared state.
Triggers
A trigger is a specialized type of stored procedure in a database that automatically executes in response to specific events on a particular table or view. These events typically include data modification actions such as inserting, updating, or deleting records. Database administrators and developers use triggers to enforce complex business rules, maintain audit trails, or ensure referential integrity across related data sets within the storage layer.
WebSockets
WebSockets provide a persistent, full-duplex communication channel over a single TCP connection between a client and a server. This technology enables real-time data transfer, allowing servers to push updates to connected clients immediately without the need for the client to constantly request new information. In ASP.NET Core, the middleware handles the WebSocket handshake and manages the ongoing connection, making it suitable for applications like chat platforms, live dashboards, or collaborative tools.
WebApplicationFactory
WebApplicationFactory is a specialized class in ASP.NET Core that simplifies the process of creating a test server for integration testing. It allows developers to host an application in memory, making it possible to send HTTP requests to the system and verify the complete response cycle without needing to deploy the code to a web server. By utilizing this tool, you can easily configure custom services or replace real database connections with mocks to ensure your API endpoints behave as expected in a real-world execution environment.
xUnit
xUnit is a free, open-source, community-focused unit testing tool for the .NET framework. It follows a clean and developer-friendly design that isolates tests into individual methods, ensuring that each test run is independent and predictable. It provides a robust set of assertions and attributes that help developers verify that specific portions of code behave as expected during the development process.
YARP
YARP is a library to help create reverse proxy servers that are high-performance, production-ready, and highly customizable. YARP is built on .NET using the infrastructure from [ASP.NET](http://ASP.NET) and .NET (.NET 6 and newer). The key differentiator for YARP is that it's been designed to be easily customized and tweaked via .NET code to match the specific needs of each deployment scenario. YARP is designed with customizability as a primary scenario rather than requiring you to break out to script or rebuild the library from source.