Doku.Common.Shared 1.0.9

Doku.Common.Shared

Doku.Common.Shared is a .NET 9 library containing shared common utilities, result patterns, and cross-cutting concerns for the Doku framework.

?? Installation

dotnet add package Doku.Common.Shared

or in Package Manager Console:

Install-Package Doku.Common.Shared

?? Features

• Result Pattern: Type-safe operation results with success/failure states
• Paged Results: Standardized pagination support
• Validation Results: Structured validation error handling
• Shared Utilities: Common utility functions
• Helper Classes: Frequently used helper classes

?? Usage

Result Pattern

using Doku.Common.Results;

// Success result without value
public IResult CreateProduct(Product product)
{
    // Business logic
    return Result.Success();
}

// Success result with value
public IResult<int> CreateProduct(Product product)
{
    var productId = SaveProduct(product);
    return Result.Success(productId);
}

// Failure result
public IResult<Product> GetProduct(int id)
{
    var product = FindProduct(id);
    if (product == null)
        return Result.Failure<Product>("Product not found");
    
    return Result.Success(product);
}

// Multiple errors
public IResult ValidateProduct(Product product)
{
    var errors = new List<string>();
    
    if (string.IsNullOrEmpty(product.Name))
        errors.Add("Product name is required");
    
    if (product.Price <= 0)
        errors.Add("Product price must be greater than 0");
    
    if (errors.Any())
        return Result.Failure(errors);
    
    return Result.Success();
}

// Using the result
var result = CreateProduct(newProduct);
if (result.IsSuccess)
{
    Console.WriteLine("Product created successfully");
}
else
{
    Console.WriteLine($"Error: {result.Error}");
    // or iterate all errors
    foreach (var error in result.Errors)
        Console.WriteLine(error);
}

// Implicit conversion for Result<T>
IResult<int> result = GetProductId();
int productId = result; // Throws if result is failure

Paged Results

using Doku.Common.Results;

public IPagedResult<Product> GetProducts(int pageNumber, int pageSize)
{
    var totalCount = _repository.Count();
    var items = _repository
        .Skip((pageNumber - 1) * pageSize)
        .Take(pageSize)
        .ToList();
    
    return PagedResult<Product>.Create(items, pageNumber, pageSize, totalCount);
}

// Using paged result
var pagedProducts = GetProducts(1, 10);
Console.WriteLine($"Page {pagedProducts.PageNumber} of {pagedProducts.TotalPages}");
Console.WriteLine($"Total items: {pagedProducts.TotalCount}");
Console.WriteLine($"Has next page: {pagedProducts.HasNextPage}");

foreach (var product in pagedProducts.Items)
{
    Console.WriteLine(product.Name);
}

// Empty result
var emptyResult = PagedResult<Product>.Empty();

Validation Results

using Doku.Common.Results;

public IValidationResult ValidateProduct(Product product)
{
    var errors = new List<IValidationError>();
    
    if (string.IsNullOrEmpty(product.Name))
        errors.Add(ValidationError.Create("Name", "Product name is required", "REQUIRED"));
    
    if (product.Price <= 0)
        errors.Add(ValidationError.Create("Price", "Price must be greater than 0", "INVALID_RANGE"));
    
    if (errors.Any())
        return ValidationResult.Invalid(errors);
    
    return ValidationResult.Valid();
}

// Using validation result
var validationResult = ValidateProduct(product);
if (validationResult.IsValid)
{
    SaveProduct(product);
}
else
{
    foreach (var error in validationResult.ValidationErrors)
    {
        Console.WriteLine($"{error.PropertyName}: {error.ErrorMessage} ({error.ErrorCode})");
    }
}

// Quick single error validation
var result = ValidationResult.Invalid("Email", "Invalid email format", "INVALID_FORMAT");

Combining with CQRS

using Doku.Common.CQRS;
using Doku.Common.Results;

// Command handler returning Result
public class CreateProductCommandHandler : ICommandHandler<CreateProductCommand, IResult<int>>
{
    public async Task<IResult<int>> HandleAsync(CreateProductCommand command, CancellationToken cancellationToken)
    {
        // Validate
        var validationResult = ValidateCommand(command);
        if (!validationResult.IsValid)
            return Result.Failure<int>(validationResult.Errors);
        
        // Business logic
        var product = MapToEntity(command);
        var productId = await _repository.AddAsync(product);
        
        return Result.Success(productId);
    }
}

// Query handler returning PagedResult
public class GetProductsQueryHandler : IQueryHandler<GetProductsQuery, IPagedResult<ProductDto>>
{
    public async Task<IPagedResult<ProductDto>> HandleAsync(GetProductsQuery query, CancellationToken cancellationToken)
    {
        var totalCount = await _repository.CountAsync();
        var products = await _repository
            .Skip((query.PageNumber - 1) * query.PageSize)
            .Take(query.PageSize)
            .ToListAsync();
        
        var dtos = _mapper.Map<ProductDto>(products);
        return PagedResult<ProductDto>.Create(dtos, query.PageNumber, query.PageSize, totalCount);
    }
}

?? Requirements

• .NET 9.0 or higher

?? Dependencies

• Doku.Core (>= 1.0.16)

?? Contributing

If you would like to contribute to the project, please fork the repository and submit a pull request.

?? License

This project is developed by Doku team.

?? Links

• Repository
• Issues

?? Contact

For questions, please contact the Doku team.