Common.Infrastructure.Lib 2.0.44

Common Infrastructure Library

Overview

The Common Infrastructure Library is a shared library that provides core infrastructure components for various applications. This library includes utilities and services that simplify tasks such as messaging, resilience, request context handling, and repository patterns. It is designed to be used as a NuGet package in other projects, allowing for easy integration of common functionality across multiple services.

This library provides a foundation of reusable components, reducing the need to rewrite common code in each project. It also includes enhanced resilience features for error handling, retry policies, and messaging patterns.

Key Components

Infrastructure

The Infrastructure module contains essential components and utilities that provide foundational services required by other parts of the application.

Messaging

The Messaging module offers messaging services for communication between different components or microservices. It helps in integrating messaging patterns like event-driven architecture and message queues.

Repositories

The Repositories module defines the repository pattern to abstract data access. It simplifies interaction with data sources and allows for more maintainable and testable code.

RequestContext

The RequestContext module is responsible for managing request-specific data, ensuring that relevant context is passed throughout the lifecycle of a request.

Resilience

The Resilience module adds reliability features to the application, including retry policies and circuit breaker patterns, which are critical for fault-tolerant applications.

Constants

The Constants class provides a collection of constant values used throughout the application. These constants help ensure consistency and avoid hardcoded values in the code.

Project Structure

Folders:

• Infrastructure: Contains core infrastructure components.
• Messaging: Provides messaging utilities and services for communication between services.
• Repositories: Contains data access abstractions and implementations for repositories.
• RequestContext: Provides tools to manage the request-specific data.
• Resilience: Implements resilience patterns, such as retries and circuit breakers.
• Constants.cs: Defines common constants used across the application.

Key Files:

• Common.Infrastructure.csproj: The project file that defines the dependencies and structure of the library.
• Common.Infrastructure.sln: The solution file for building and managing the project.
• Constants.cs: A file defining constant values used across the library.

Installation

Step 1: Add the NuGet Package

You can integrate the Common Infrastructure Library into your project by adding the NuGet package:

dotnet add package Common.Infrastructure --version <version-number>

Replace <version-number> with the desired version of the package.

Step 2: Usage

Once the library is added to your project, you can use the provided classes and utilities:

• Messaging: For sending and receiving messages between components.
• Resilience: For adding retry policies and circuit breakers.
• Repositories: For implementing data access layers using the repository pattern.
• RequestContext: For accessing and managing request-specific context.
• Constants: For reusing common constant values across the application.

Example usage in your project:

using Common.Infrastructure.Messaging;
using Common.Infrastructure.Resilience;

public class MyService
{
    private readonly IMessageService _messageService;
    private readonly IResilienceService _resilienceService;

    public MyService(IMessageService messageService, IResilienceService resilienceService)
    {
        _messageService = messageService;
        _resilienceService = resilienceService;
    }

    public void PerformAction()
    {
        // Use resilience service for retry logic
        _resilienceService.ExecuteWithRetry(() => 
        {
            // Send message using message service
            _messageService.SendMessage("My message");
        });
    }
}

Development and Contribution

Prerequisites

Before building the library locally, make sure you have the following installed:

• .NET SDK: Required to build the library. Download from here.

Step 1: Clone the Repository

Clone the repository to your local machine:

git clone <repository-url>
cd <repository-name>

Step 2: Build the Library

To build the library, use the following command:

dotnet build

Step 3: Run Tests

If there are unit tests included, run the tests to ensure everything works as expected:

dotnet test

Step 4: Publish to NuGet

To publish the package to NuGet, use the following command:

dotnet nuget push <package-file> --api-key <api-key> --source https://api.nuget.org/v3/index.json

Replace <package-file> with the .nupkg file and <api-key> with your NuGet API key.

License

This project is licensed under the MIT License - see the LICENSE file for details.

Conclusion

The Common Infrastructure Library provides a set of reusable components that simplify common tasks and patterns in .NET applications. It is designed to be packaged as a NuGet library for easy integration into other projects. With components for messaging, resilience, data access, and request context management, this library helps build robust, maintainable applications.