"Description": "Learn how to efficiently build .NET projects with the ABP Framework's build command, handling complex dependencies and configurations seamlessly."
}
```
# Build Command
Building a .NET project is hard when the project references a project reference outside of the solution or even from a different GIT repository. This command builds a GIT repository and it's depending repositories or a single .NET solution File. In order ```build``` command to work, its **executing directory** or passed ```--working-directory``` parameter's directory must contain one of;
"Description": "Discover the differences between the old and new ABP CLI, including features and commands, to enhance your ABP development experience."
}
```
# Old ABP CLI vs New ABP CLI
ABP CLI (Command Line Interface) is a command line tool to perform some common operations for ABP based solutions or ABP Studio features. With **v8.2+**, the old/legacy ABP CLI has been replaced with a new [CLI](index.md) system to align with the new templating system and [ABP Studio](../studio/index.md). Also, some superior features/commands have been introduced with the new CLI, such as `kube-connect` and `kube-intercept` commands.
"Description": "Discover how to install and use the new ABP CLI for streamlined operations in ABP-based solutions, enhancing your development experience!"
}
```
# ABP CLI
ABP CLI (Command Line Interface) is a command line tool to perform some common operations for ABP based solutions or ABP Studio features.
"Description": "Explore sample commands to create ABP solutions using the ABP CLI, including Angular projects and database options for developers."
}
```
# ABP CLI - New Solution Sample Commands
The `abp new` command creates an ABP solution or other artifacts based on an ABP template. [ABP CLI](../cli/index.md) has several parameters to create a new ABP solution. In this document we will show you some sample commands to create a new solution. All the project names are `Acme.BookStore`. Currently, the available mobile projects are `React Native` and `MAUI` mobile app (they are *available for****Team*** *or higher licenses*). Available database providers are `Entity Framework Core` and `MongoDB`. All the commands starts with `abp new`.
"Description": "Join the ABP community! This guide outlines how to contribute code and articles to enhance the ABP Framework."
}
```
# Contribution Guide
ABP is an [open source](https://github.com/abpframework) and community driven project. This guide is aims to help anyone wants to contribute to the project.
"Description": "Learn how to effectively deploy your ABP application in a clustered environment, ensuring smooth operation across multiple instances."
}
```
# Deploying to a Clustered Environment
This document explains the topics that you should consider when deploying your application to a clustered environment where multiple instances of your application run concurrently.
"Description": "Learn how to configure OpenIddict in your AuthServer project for both Development and Production environments with this comprehensive guide."
}
```
# Configuring OpenIddict
This document introduces how to configure `OpenIddict` in the `AuthServer` project.
"Description": "Learn how to optimize your ABP application for production with essential configurations and caching strategies for better performance."
}
```
# Configuring Your Application for Production Environments
ABP predefines the configurations for the best performance for common deployment scenarios.
"Description": "Learn how to deploy distributed and microservice solutions with ABP, ensuring seamless communication and effective application management."
}
```
# Deploying Distributed / Microservice Solutions
ABP is designed for distributed and microservice systems, where multiple applications and/or services communicate internally. All of its features are compatible with distributed scenarios. This document highlights some points you should consider when deploying your distributed or microservice solution.
"Description": "Learn how to handle common issues with reverse proxies in ASP.NET Core using forwarded headers middleware for your ABP applications."
}
```
# Forwarded Headers
Reverse proxies and load balancers play a crucial role in modern web application architectures. When an application is deployed behind these proxies and load balancers, several specific issues can arise. This document will discuss these issues in detail, explain how ASP.NET Core's forwarded headers middleware can address them, and provide a code example for configuring forwarded headers in an ABP application.
"Description": "Learn how to effectively deploy your ABP applications with essential guides on SSL, OpenIddict, and best practices for .NET environments."
}
```
# Deployment
Deploying an ABP application is not different than deploying any .NET or ASP.NET Core application. You can deploy it to a cloud provider (e.g., Azure, AWS, Google Could) or an on-premise server, IIS or any other web server. ABP's documentation doesn't contain much information on deployment. You can refer to your provider's documentation.
"Description": "Learn how to obtain and configure an SSL certificate for your application to enhance security, trust, and ownership verification."
}
```
# Configuring SSL certificate(HTTPS)
A website needs an SSL certificate to keep user data secure, verify ownership, prevent attackers from creating a fake version of the site, and gain user trust.
"Description": "Learn how to automatically create API controllers in ABP Framework, simplifying your application's REST API setup with minimal configuration."
}
```
# Auto API Controllers
Once you create an [application service](../architecture/domain-driven-design/application-services.md), you generally want to create an API controller to expose this service as an HTTP (REST) API endpoint. A typical API controller does nothing but redirects method calls to the application service and configures the REST API using attributes like [HttpGet], [HttpPost], [Route]... etc.
"Description": "Learn how to use ABP's dynamic C# API client proxies for seamless HTTP service calls, simplifying authentication, serialization, and error handling."
}
```
# Dynamic C# API Client Proxies
ABP can dynamically create C# API client proxies to call your remote HTTP services (REST APIs). In this way, you don't need to deal with `HttpClient` and other low level details to call remote services and get results.
"Description": "Learn how Integration Services facilitate communication between microservices, enhancing your ABP Framework applications with seamless integration."
}
```
# Integration Services
The *Integration Service* concept was created to distinguish the [application services](../architecture/domain-driven-design/application-services.md) that are built for inter-module (or inter-microservice) communication from the application services that are intended to be consumed from a UI or a client application.
"Description": "Learn how to use ABP's Application Configuration Endpoint to access user permissions, settings, and tenant info for your application."
}
```
# Application Configuration Endpoint
ABP provides a pre-built and standard endpoint that contains some useful information about the application/service. Here, is the list of some fundamental information at this endpoint:
"Description": "Explore ABP's standard HTTP API endpoints for easy access to application configuration and localization information."
}
```
# Standard HTTP API Endpoints
ABP provides some pre-built and standard endpoints that contains useful information about the application or service, such as localization entries and settings. Here, is the list of the pre-built endpoints:
"Description": "Learn how to utilize ABP's application localization endpoint to fetch localization resources and enhance your UI application effectively."
}
```
# Application Localization Endpoint
ABP provides a pre-built and standard endpoint that returns all the [localization](../../fundamentals/localization.md) resources and texts defined in the server.
"Description": "Learn how to create Static C# API client proxies with ABP for seamless HTTP service calls, simplifying authentication, serialization, and error handling."
}
```
# Static C# API Client Proxies
ABP can create C# API client proxy code to call your remote HTTP services (REST APIs). In this way, you don't need to deal with `HttpClient` and other low level details to call remote services and get results.
"Description": "Learn how to integrate Swagger with ABP Framework for seamless REST API documentation and service connectivity with minimal setup."
}
```
# Swagger Integration
[Swagger (OpenAPI)](https://swagger.io/) is a language-agnostic specification for describing REST APIs. It allows both computers and humans to understand the capabilities of a REST API without direct access to the source code. Its main goals are to:
"Description": "Learn how to implement API versioning in ABP Framework, enabling seamless integration with ASP.NET while supporting static client proxies."
}
```
# API Versioning System
ABP integrates the [ASPNET-API-Versioning](https://github.com/dotnet/aspnet-api-versioning/wiki) feature and adapts to C# and JavaScript Static Client Proxies and [Auto API Controller](./auto-controllers.md).
"Description": "Explore best practices for implementing the application layer in your solution with Domain Driven Design principles."
}
```
# Best Practices: Application Layer
The following documents suggest some best-practices that you can use while implementing the application layer of your solution by following the Domain Driven Design principles:
"Description": "Explore best practices for implementing Application Services in ABP Framework, ensuring effective use of Domain-Driven Design principles."
}
```
# Application Services Best Practices & Conventions
> This document offers best practices for implementing Application Services classes in your modules and applications based on Domain-Driven-Design principles.
"Description": "Explore best practices for data access in your solutions using Entity Framework Core and MongoDB, aligned with Domain Driven Design principles."
}
```
# Best Practices: Data Access
The following documents suggest some best-practices that you can use while implementing the database integration layer of your solution by following Domain Driven Design principles:
"Description": "Explore best practices for implementing Data Transfer Objects in your applications, guided by Domain-Driven Design principles."
}
```
# Data Transfer Objects Best Practices & Conventions
> This document offers best practices for implementing Data Transfer Object classes in your modules and applications based on Domain-Driven-Design principles.
"Description": "Discover best practices for implementing the domain layer using Domain Driven Design principles, including entities, repositories, and domain services."
}
```
# Best Practices: Domain Layer
The following documents suggest some best-practices that you can use while implementing the domain layer of your solution by following the Domain Driven Design principles:
"Description": "Learn best practices for implementing Domain Services in your applications, guided by Domain-Driven Design principles."
}
```
# Domain Services Best Practices & Conventions
> This document offers best practices for implementing Domain Service classes in your modules and applications based on Domain-Driven-Design principles.
"Description": "Explore best practices for implementing Aggregate Root and Entity classes in your applications using Domain-Driven Design principles."
}
```
# Entity Best Practices & Conventions
> This document offers best practices for implementing Aggregate Root and Entity classes in your modules and applications based on Domain-Driven-Design principles.
"Description": "Explore best practices for developing ABP Framework modules, focusing on Domain Driven Design, DBMS independence, and microservice compatibility."
}
```
# Module Development Best Practices & Conventions
This document describes the **best practices** and **conventions** for those who want to develop **modules** that satisfy the following specifications:
"Description": "Discover best practices for structuring ABP modules with clear conventions on solution architecture, layered design, and package dependencies."
}
```
# Module Architecture Best Practices & Conventions
"Description": "Explore the Application Layer in Domain Driven Design, learn about its components, and how it facilitates application logic in ABP Framework."
}
```
# Domain Driven Design: Application Layer
Application Layer mediates between the Presentation and Domain Layers. Orchestrates business objects to perform specific application tasks and implements use cases as the application logic. Here, is the list of the building blocks of the Application Layer:
"Description": "Learn how to implement application services in the ABP Framework to expose domain logic and streamline presentation layer interactions."
}
```
# Application Services
Application services are used to implement the **use cases** of an application. They are used to **expose domain logic to the presentation layer**.
"Description": "Learn how Data Transfer Objects (DTOs) enhance data handling between application and presentation layers, ensuring clean architecture and abstraction."
}
```
# Data Transfer Objects
**Data Transfer Objects** (DTO) are used to transfer data between the **Application Layer** and the **Presentation Layer** or other type of clients.
"Description": "Explore the Domain Layer in Domain Driven Design, featuring essential building blocks like Entities, Value Objects, and Domain Services."
}
```
# Domain Driven Design: Domain Layer
Domain Layer contains business objects and the core (domain) business rules of the application and it's the heart of the application. Here, is the list of building blocks of the Domain Layer:
"Description": "Learn how to implement Domain Services in ABP Framework for core business logic, enhancing your Domain Driven Design solutions effectively."
}
```
# Domain Services
In a [Domain Driven Design](../domain-driven-design) (DDD) solution, the core business logic is generally implemented in aggregates ([entities](./entities.md)) and the Domain Services. Creating a Domain Service is especially needed when;
"Description": "Learn about entities in DDD, their structure, and best practices for using GUID keys in the ABP Framework for effective data modeling."
}
```
# Entities
Entities are one of the core concepts of DDD (Domain Driven Design). Eric Evans describes it as "*An object that is not fundamentally defined by its attributes, but rather by a thread of continuity and identity*".
"Description": "Discover how ABP Framework simplifies Domain Driven Design (DDD) for developers with structured layers and collaboration for complex software needs."
"Description": "Learn about Value Objects in domain-driven design, how to implement them in your projects, and why they matter for clean architecture."
}
```
# Value Objects
> An object that represents a descriptive aspect of the domain with no conceptual identity is called a VALUE OBJECT.
"Description": "Discover ABP's opinionated yet flexible architecture for building enterprise software, featuring modularity and comprehensive tools for developers."
}
```
# ABP Architecture
ABP offers an **opinionated architecture** to build enterprise software solutions. In this way, the solution structure and development model is pretty well defined. All the solution templates, tooling, pre-built modules, guides and documentation are compatible to that development model.
"Description": "Explore microservice architecture and learn how it enhances modularity, scalability, and continuous delivery for efficient application development."
}
```
# Microservice Architecture
*"Microservices are a software development technique—a variant of the **service-oriented architecture** (SOA) architectural style that structures an application as a collection of **loosely coupled services**. In a microservices architecture, services are **fine-grained** and the protocols are **lightweight**. The benefit of decomposing an application into different smaller services is that it improves **modularity**. This makes the application easier to understand, develop, test, and become more resilient to architecture erosion. It **parallelizes development** by enabling small autonomous teams to **develop, deploy and scale** their respective services independently. It also allows the architecture of an individual service to emerge through **continuous refactoring**. Microservices-based architectures enable **continuous delivery and deployment**."*
"Description": "Learn how to build modular applications with ABP Framework, including best practices, templates, and CLI support for seamless development."
"Description": "Learn how to extend entities in ABP Framework by adding extra properties to seamlessly customize your application modules."
}
```
# Customizing the Application Modules: Extending Entities
In some cases, you may want to add some additional properties (and database fields) for an entity defined in a depended module. This section will cover some different approaches to make this possible.
"Description": "Learn how to customize and reuse ABP's pre-built application modules for efficient and modular application development."
}
```
# Customizing the Existing Modules
ABP has been designed to support to build fully [modular applications](../../modularity/basics.md) and systems. It also provides some [pre-built application modules](../../../../modules) those are **ready to use** in any kind of application.
"Description": "Learn how to customize ABP application modules by overriding services using dependency injection for tailored business logic."
}
```
# Customizing the Application Modules: Overriding Services
You may need to **change behavior (business logic)** of a depended module for your application. In this case, you can use the power of the [dependency injection system](../../../fundamentals/dependency-injection.md) to replace a service, controller or even a page model of the depended module by your own implementation.
"Description": "Learn how to extend existing entities in ABP Framework modules by adding new properties seamlessly across the entire system."
}
```
# Module Entity Extensions
Module entity extension system is a **high level** extension system that allows you to **define new properties** for existing entities of the depended modules. It automatically **adds properties to the entity, database, HTTP API and the user interface** in a single point.
"Description": "Learn how to customize and override the user interface for ABP Framework modules using various UI frameworks like ASP.NET Core, Angular, and Blazor."
}
```
# Overriding the User Interface
You may want to override a page, a component, a JavaScript, CSS or an image file of your depended module. Overriding the UI completely depends on the UI framework you're using. Select the UI framework to continue:
"Description": "Learn how to load modules as plug-ins in your ABP Framework application, enabling flexible module management without direct assembly references."
}
```
# Plug-In Modules
It is possible to load [modules](../modularity/basics.md) as plug-ins. That means you may not reference to a module's assembly in your solution, but you can load that module in the application startup just like any other module.
"Description": "Learn how ABP Framework enables developers to build powerful multi-tenant applications, optimizing resource sharing for SaaS solutions."
}
```
# Multi-Tenancy
Multi-Tenancy is a widely used architecture to create **SaaS applications** where the hardware and software **resources are shared by the customers** (tenants). ABP provides all the base functionalities to create **multi tenant applications**.
"Description": "Learn how to integrate Dapper with ABP Framework for high-performance data access, simplifying repository creation while leveraging EF Core."
}
```
# Dapper Integration
[Dapper](https://github.com/DapperLib/Dapper) is a simple and lightweight object mapper for .NET. A key feature of Dapper is its [high performance](https://github.com/DapperLib/Dapper#performance) compared to other ORMs.
"Description": "Learn how to integrate Entity Framework Core with ABP applications, including installation and configuration for seamless database management."
}
```
# Entity Framework Core Integration
This document explains how to integrate EF Core as an ORM provider to ABP based applications and how to configure it.
"Description": "Learn how to customize database migrations in EF Core with the ABP Framework, enhancing your application's structure and management."
}
```
# EF Core Database Migrations
This document begins by **introducing the default structure** provided by [the application startup template](../../../solution-templates/layered-web-application) and **discusses various scenarios** you may want to implement for your own application.
"Description": "Learn how to switch your ABP Framework application to the MySQL database provider, replacing the default SQL Server setup effortlessly."
}
```
# Switch to EF Core MySQL Provider
> [ABP CLI](../../../cli/index.md) and the [Get Started](https://abp.io/get-started) page already provides an option to create a new solution with MySQL. See [that document](./other-dbms.md) to learn how to use. This document provides guidance for who wants to manually switch to MySQL after creating the solution.
"Description": "Learn how to switch to the Oracle Devart provider for your ABP application, ensuring compatibility with Oracle v12.2+ for seamless database integration."
}
```
# Switch to EF Core Oracle Devart Provider
This document explains how to switch to the **Oracle** database provider for **[the application startup template](../../../solution-templates/layered-web-application)** which comes with SQL Server provider pre-configured.
"Description": "Learn how to switch your ABP application to use the EF Core Oracle provider, ensuring compatibility with Oracle version 12.2 and above."
}
```
# Switch to EF Core Oracle Provider
This document explains how to switch to the **Oracle** database provider for **[the application startup template](../../../solution-templates/layered-web-application)** which comes with SQL Server provider pre-configured.
"Description": "Learn how to switch your ABP application to use the Oracle database provider, with guidance on both official and commercial drivers."
}
```
# Switch to EF Core Oracle Provider
> [ABP CLI](../../../cli/index.md) and the [Get Started](https://abp.io/get-started) page already provides an option to create a new solution with Oracle. See [that document](other-dbms.md) to learn how to use. This document provides guidance for who wants to manually switch to Oracle after creating the solution.
"Description": "Learn how to switch your DBMS for Entity Framework Core in ABP Framework, allowing flexibility to choose your preferred database solution."
}
```
# Switch to Another DBMS for Entity Framework Core
[ABP CLI](../../../cli/index.md) provides a `-dbms` option to allow you to choose your Database Management System (DBMS) while creating a new solution. It accepts the following values:
"Description": "Learn how to switch your ABP Framework application from SQL Server to PostgreSQL with step-by-step guidance for a smooth transition."
}
```
# Switch to EF Core PostgreSQL Provider
> [ABP CLI](../../../cli) and the [Get Started](https://abp.io/get-started) page already provides an option to create a new solution with PostgreSQL. See [that document](./other-dbms.md) to learn how to use. This document provides guidance for who wants to manually switch to PostgreSQL after creating the solution.
"Description": "Learn how to switch your ABP Framework application to use the SQLite database provider with this step-by-step guide."
}
```
# Switch to EF Core SQLite Provider
> [ABP CLI](../../../cli) and the [Get Started](https://abp.io/get-started) page already provides an option to create a new solution with SQLite. See [that document](other-dbms.md) to learn how to use. This document provides guidance for who wants to manually switch to SQLite after creating the solution.
"Description": "Explore ABP's database-agnostic data access, featuring repositories and unit of work for Entity Framework Core, MongoDB, and Dapper."
}
```
# Data Access
ABP was designed as database agnostic. It can work any type of data source by the help of the [repository](../architecture/domain-driven-design/repositories.md) and [unit of work](../architecture/domain-driven-design/unit-of-work.md) abstractions. Currently, the following providers are implemented as official:
"Description": "Learn how to integrate MongoDB with ABP applications, including installation and configuration steps for seamless database management."
}
```
# MongoDB Integration
This document explains how to integrate MongoDB as a database provider to ABP based applications and how to configure it.
"Description": "Learn how to effectively start your ABP application using templates, and understand the integration and configuration details for customization."
}
```
# ABP Application Startup
You typically use the [ABP CLI](../../cli)'s `abp new` command to [get started](../../get-started/layered-web-application.md) with one of the pre-built [startup solution templates](../../solution-templates). When you do that, you generally don't need to know the details of how the ABP is integrated with your application or how it is configured and initialized. The startup template also comes with the fundamental ABP packages and [application modules](../../modules) are pre-installed and configured for you.
"Description": "Learn how to leverage ABP Framework's enhanced authorization features, including permissions and policies, to secure your applications efficiently."
}
```
# Authorization
Authorization is used to check if a user is allowed to perform some specific operations in the application.
"Description": "Learn how to integrate Autofac with ABP Framework for advanced dependency injection features, enhancing your .NET applications effortlessly."
}
```
# Autofac Integration
[Autofac](https://autofac.org/) is one of the most used dependency injection frameworks for .NET. It provides advanced features compared to .Net Core's standard DI library, like dynamic proxying and property injection.
"Description": "Learn how to implement distributed caching in ABP Framework for efficient memory management and improved application performance."
}
```
# Distributed Caching
ABP extends the [ASP.NET Core distributed cache](https://docs.microsoft.com/en-us/aspnet/core/performance/caching/distributed) to provide a more comfortable and easy-to-use cache service.
"Description": "Explore how to leverage ASP.NET Core's flexible configuration system with ABP Framework for effective application management and customization."
}
```
# Configuration
ASP.NET Core has an flexible and extensible key-value based configuration system. In fact, the configuration system is a part of Microsoft.Extensions libraries and it is independent from ASP.NET Core. That means it can be used in any type of application. See [Microsoft's documentation](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration/) to learn the configuration infrastructure. ABP is 100% compatible with the configuration system.
"Description": "Learn how to manage connection strings in ABP for modular and multi-tenant applications, enabling flexible database configurations."
}
```
# Connection Strings
> Connection string system is especially needed when you want to create or use a modular system. If you have a monolithic application with a single database, you can go with the [ABP startup solution template](../../solution-templates/layered-web-application), which is properly configured for you.
"Description": "Learn how to leverage ABP's Dependency Injection system for modular service registration and dynamic proxying with best practices and tips."
}
```
# Dependency Injection
ABP's Dependency Injection system is developed based on Microsoft's [dependency injection extension](https://medium.com/volosoft/asp-net-core-dependency-injection-best-practices-tips-tricks-c6e9c67f9d96) library (Microsoft.Extensions.DependencyInjection nuget package). So, its documentation is valid in ABP too.
"Description": "Learn how to implement dynamic claims in ABP Framework to ensure real-time updates of claims in user sessions for enhanced security."
}
```
# Dynamic Claims
When a client authenticates and obtains an access token or an authentication cookie, the claims in that token or cookie are not changed unless it re-authenticates. That is not a problem for most claims since the claim values do not frequently change. However, for some claims, it may be required to immediately see the impact after the claim values change in the current session. For example, if a role is revoked from a user, you want to see its effect in the next request. Otherwise, the user will continue to use that role's permissions until re-login to the application.
"Description": "Learn how ABP Framework simplifies exception handling with automatic formatting, localization, and HTTP status code mapping for seamless API responses."
}
```
# Exception Handling
ABP provides a built-in infrastructure and offers a standard model for handling exceptions.
"Description": "Learn how to integrate FluentValidation with ABP Framework for enhanced validation capabilities in your applications."
}
```
# FluentValidation Integration
ABP [Validation](./validation.md) infrastructure is extensible. [Volo.Abp.FluentValidation](https://www.nuget.org/packages/Volo.Abp.FluentValidation) NuGet package extends the validation system to work with the [FluentValidation](https://fluentvalidation.net/) library.
"Description": "Explore the essential building blocks of ABP Framework solutions, covering startup, authorization, caching, and more for efficient development."
}
```
# ABP Fundamentals: Overview
The following documents explains the fundamental building blocks to create ABP solutions:
"Description": "Learn how to effectively use ABP's localization system, enhancing your applications with features from Microsoft.Extensions.Localization."
}
```
# Localization
ABP's localization system is seamlessly integrated to the `Microsoft.Extensions.Localization` package and compatible with the [Microsoft's localization documentation](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/localization). It adds some useful features and enhancements to make it easier to use in real life application scenarios.
"Description": "Learn how to utilize ASP.NET Core's logging system in ABP Framework for effective application logging and monitoring."
}
```
# Logging
ABP doesn't implement any logging infrastructure. It uses the [ASP.NET Core's logging system](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/logging).
"Description": "Learn how ABP's object extension system lets you add properties to existing objects effortlessly without altering the original class."
}
```
# Object Extensions
ABP provides an **object extension system** to allow you to **add extra properties** to an existing object **without modifying** the related class. This allows to extend functionalities implemented by a depended [application module](../../modules), especially when you want to [extend entities](../architecture/modularity/extending/customizing-application-modules-extending-entities.md) and [DTOs](../architecture/modularity/extending/customizing-application-modules-overriding-services.md) defined by the module.
"Description": "Learn how to utilize the options pattern in ABP Framework to configure settings efficiently for your applications."
}
```
# Options
Microsoft has introduced [the options pattern](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration/options) that is used to configure a group of settings used by the framework services. This pattern is implemented by the [Microsoft.Extensions.Options](https://www.nuget.org/packages/Microsoft.Extensions.Options) NuGet package, so it is usable by any type of applications in addition to ASP.NET Core based applications.
"Description": "Learn how to enhance your ABP application with Redis Cache integration for improved performance and advanced caching capabilities."
}
```
# Redis Cache
ABP [Caching System](./caching.md) extends the [ASP.NET Core distributed cache](https://docs.microsoft.com/en-us/aspnet/core/performance/caching/distributed). So, **any provider** supported by the standard ASP.NET Core distributed cache can be usable in your application and can be configured just like **documented by Microsoft**.
"Description": "Learn how ABP Framework enhances ASP.NET Core validation with automatic checks, localization, and FluentValidation integration for better input handling."
}
```
# Validation
Validation system is used to validate the user input or client request for a particular controller action or service method.
"Description": "Discover ABP's extensible audit logging system, enabling automated, configurable tracking of web request activities and changes for enhanced security."
}
```
# Audit Logging
[Wikipedia](https://en.wikipedia.org/wiki/Audit_trail): "*An audit trail (also called **audit log**) is a security-relevant chronological record, set of records, and/or destination and source of records that provide documentary evidence of the sequence of activities that have affected at any time a specific operation, procedure, or event*".
"Description": "Integrate Hangfire with the ABP Framework for efficient background job management, ensuring code independence and seamless functionality."
}
```
# Hangfire Background Job Manager
[Hangfire](https://www.hangfire.io/) is an advanced background job manager. You can integrate Hangfire with the ABP to use it instead of the [default background job manager](../background-jobs). In this way, you can use the same background job API for Hangfire and your code will be independent of Hangfire. If you like, you can directly use Hangfire's API, too.
"Description": "Learn how to implement background jobs in ABP Framework for efficient task execution, ensuring persistence and reliability in your applications."
"Description": "Learn how to integrate Quartz with ABP Framework for advanced background job management, enhancing your job processing capabilities effortlessly."
}
```
# Quartz Background Job Manager
[Quartz](https://www.quartz-scheduler.net/) is an advanced background job manager. You can integrate Quartz with the ABP to use it instead of the [default background job manager](../background-jobs). In this way, you can use the same background job API for Quartz and your code will be independent of Quartz. If you like, you can directly use Quartz's API, too.
"Description": "Learn how to install and configure RabbitMQ for background job execution in your ABP Framework projects effectively."
}
```
# RabbitMQ Background Job Manager
RabbitMQ is an industry standard message broker. While it is typically used for inter-process communication (messaging / distributed events), it is pretty useful to store and execute background jobs in FIFO (First In First Out) order.
"Description": "Integrate Hangfire with ABP Framework to efficiently manage background jobs and leverage advanced scheduling for recurring tasks."
}
```
# Hangfire Background Worker Manager
[Hangfire](https://www.hangfire.io/) is an advanced background jobs and worker manager. You can integrate Hangfire with the ABP to use it instead of the [default background worker manager](../background-workers).
"Description": "Integrate Quartz as your background worker manager in ABP Framework with easy installation steps and enhance your application's performance."
}
```
# Quartz Background Worker Manager
[Quartz](https://www.quartz-scheduler.net/) is an advanced background worker manager. You can integrate Quartz with the ABP to use it instead of the [default background worker manager](../background-workers). ABP simply integrates quartz.
"Description": "Learn how to configure Azure Blob storage for your project using the ABP Framework with this concise guide on the BLOB Storing Azure Provider."
}
```
# BLOB Storing Azure Provider
BLOB Storing Azure Provider can store BLOBs in [Azure Blob storage](https://azure.microsoft.com/en-us/services/storage/blobs/).
Ma Liming
4 months ago
GitHub