Hasim.Infrastructure 0.1.2

Hasim.Infrastructure

A .NET 8 class library providing shared infrastructure building blocks — a generic EF Core repository, a unit of work, and DI registration — to accelerate .NET application development across the Hasim.* ecosystem.

This repository holds the reusable infrastructure services and helpers consumed by the application projects. It is published as a NuGet package (Hasim.Infrastructure) and referenced wherever cross-cutting infrastructure is needed.

✨ Features

• Generic EF Core repository — IEntityRepository<TEntity, TKey> / EntityRepository<TEntity, TKey> with async CRUD and query helpers, soft-delete aware.
• Unit of work — UnitOfWork that applies auditable timestamps, soft delete, and delegates audit creation.
• DI module — InfrastructureModule registers the repository via an open-generic AddScoped.
• Packaged as a NuGet library — one shared infrastructure dependency for your whole ecosystem.

📦 Installation

dotnet add package Hasim.Infrastructure

🚀 Getting Started

Hasim.Infrastructure is the infrastructure layer. Reference it from your application projects and use its services through dependency injection.

1. Add the package

dotnet add package Hasim.Infrastructure

2. Reference the infrastructure layer

Add a package reference from your application project to Hasim.Infrastructure.

3. Use the repository in a service

The repository stages changes; the service persists them via the unit of work or context:

using Hasim.Infrastructure.Contracts;

public class DriverService
{
    private readonly IEntityRepository<Driver, int> _repository;

    public DriverService(IEntityRepository<Driver, int> repository)
    {
        _repository = repository;
    }

    public async Task<Driver?> GetDriverAsync(int id) => await _repository.FindByIdAsync(id);
}

Register it with the InfrastructureModule, or manually:

services.AddScoped(typeof(IEntityRepository<,>), typeof(EntityRepository<,>));

Transactions with ExecutionStrategy

For operations that require multiple repository calls within a transaction, use ExecutionStrategy to enable automatic retries on transient errors:

using Hasim.Infrastructure.Contracts;

public class UserService
{
    private readonly IUnitOfWork _unitOfWork;
    private readonly IUserRepository _userRepository;
    private readonly IRoleRepository _roleRepository;

    public UserService(
        IUnitOfWork unitOfWork,
        IUserRepository userRepository,
        IRoleRepository roleRepository)
    {
        _unitOfWork = unitOfWork;
        _userRepository = userRepository;
        _roleRepository = roleRepository;
    }

    public async Task CreateUserAsync(
        CreateUserRequest request,
        CancellationToken cancellationToken = default)
    {
        var strategy = _unitOfWork.CreateExecutionStrategy();

        await strategy.ExecuteAsync(async () =>
        {
            await using var transaction = await _unitOfWork.BeginTransactionAsync();

            try
            {
                var user = new User
                {
                    Id = Guid.NewGuid(),
                    Email = request.Email,
                    Name = request.Name
                };

                await _userRepository.AddAsync(user);

                var role = await _roleRepository.GetByNameAsync("User", cancellationToken);
                user.RoleId = role.Id;

                await _unitOfWork.AutomaticSavingAsync(cancellationToken);

                await _unitOfWork.CommitAsync();
            }
            catch
            {
                await transaction.RollbackAsync();
                throw;
            }
        });
    }
}

Flow:

CreateUserAsync()
      │
      ▼
CreateExecutionStrategy()
      │
      ▼
ExecuteAsync()
      │
      ▼
BeginTransactionAsync()
      │
      ├── Add User
      │
      ├── Add/Update Role
      │
      ├── AutomaticSavingAsync()
      │
      ▼
CommitAsync()
      │
      ▼
      OK

If a transient error occurs, for example a temporary SQL Server outage:

ExecutionStrategy
      │
      ├── Attempt 1
      │      └── transient error
      │
      ├── Attempt 2
      │      └── transient error
      │
      └── Attempt 3
             └── OK

🧱 Architecture

Hasim.Infrastructure/
├── Hasim.Infrastructure.sln
├── Src/
│   ├── Hasim.Infrastructure/          # the class library (net8.0)
│   │   ├── Contracts/                 # IEntityRepository, EntityRepository
│   │   ├── Configurations/            # UnitOfWork, IUnitOfWork
│   │   └── Modules/                   # InfrastructureModule (DI registration)
│   └── Hasim.Infrastructure.UnitTests/ # xUnit tests
└── assets/images/Logo.png             # package icon

Components

📚 Dependencies

• Hasim
• Hasim.Auditify
• Hasim.EntityFrameworkCore
• Hasim.Injectify

🔧 Requirements

• .NET 8.0 SDK

🤝 Contributing

1. Fork the repository.
2. Create a feature branch.
3. Submit a pull request.

📄 License

This project is licensed under the MIT License.