Hasim 0.1.3

Hasim

A lightweight .NET 8 foundation for ASP.NET Core applications, providing reusable base types and common abstractions for modern .NET apps.

Built to sit alongside the Hasim.* ecosystem (Hasim.Core, Hasim.EntityFrameworkCore, Hasim.Auditify, Hasim.Injectify), this library ships a dispose-pattern base type (IDisposable + IAsyncDisposable) and a current-user abstraction that reads the authenticated ClaimsPrincipal from IHttpContextAccessor — small, focused building blocks for your web app.

✨ Features

• Disposable base type — Disposable implements the standard dispose pattern with a finalizer, GC.SuppressFinalize, and virtual synchronous (DisposeCore) / asynchronous (DisposeAsyncCore) hooks.
• Current-user abstraction — ICurrentUser / CurrentUser resolve the authenticated user's id, name, email and authentication state without touching HttpContext directly.
• Packaged as a NuGet library — drop it into any ASP.NET Core app.
• Mapping contracts — IMapTo<TDestination> and IMapFrom<TSource> define manual mapping contracts between objects.

📦 Installation

dotnet add package Hasim

🚀 Getting Started

1. Register the services

Register IHttpContextAccessor and the current-user services with your DI container (e.g. in Program.cs):

builder.Services.AddHttpContextAccessor();
builder.Services.AddScoped<ICurrentUser, CurrentUser>();

2. Use the current user

Inject ICurrentUser into your components or services and inspect the authenticated principal:

using Hasim.Services;

public class MyComponent(ICurrentUser user)
{
    public string? DisplayName => user.UserName;
    public string? Email => user.Email;
    public int? Id => user.AsIntegerReadId;
    public bool Authenticated => user.IsAuthenticated;
}

3. Derive from Disposable

Create a disposable service by extending Hasim.Common.Disposable and overriding the dispose hooks you need:

using Hasim.Common;

public class MyService : Disposable
{
    protected override void DisposeCore() => /* release unmanaged/synchronous resources */;

    protected override async ValueTask DisposeAsyncCore()
    {
        // release async resources, then call DisposeCore() via base
        await base.DisposeAsyncCore();
    }
}

4. Use the mapping contracts

Implement IMapTo<TDestination> to map the current object to another type, and IMapFrom<TSource> to map from a source object to the current type:

using Hasim.Mapping;

public class UserDto : IMapFrom<User>
{
    public Guid Id { get; set; }
    public string FullName { get; set; } = string.Empty;
    public string Email { get; set; } = string.Empty;

    public void MapFrom(User source)
    {
        Id = source.Id;
        FullName = $"{source.FirstName} {source.LastName}";
        Email = source.Email;
    }
}

public class CreateUserDto : IMapTo<User>
{
    public string FirstName { get; set; } = string.Empty;
    public string LastName { get; set; } = string.Empty;
    public string Email { get; set; } = string.Empty;

    public User MapTo()
    {
        return new User
        {
            FirstName = FirstName,
            LastName = LastName,
            Email = Email
        };
    }
}

public class User
{
    public Guid Id { get; set; }
    public string FirstName { get; set; } = string.Empty;
    public string LastName { get; set; } = string.Empty;
    public string Email { get; set; } = string.Empty;
}

🧱 Architecture

Hasim/
└── Src/Hasim/
    ├── Common/
    │   └── Disposable.cs       # IDisposable + IAsyncDisposable base type
    ├── Mapping/
    │   ├── MapFrom.cs          # IMapFrom<TSource> interface
    │   └── MapTo.cs            # IMapTo<TDestination> interface
    └── Services/
        └── CurrentUser.cs      # ICurrentUser interface + CurrentUser implementation

CurrentUser members

📚 Dependencies

• Microsoft.AspNetCore.Http.Abstractions 2.3.x

🔧 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.