Strongflow 0.0.1-beta.25

Strongflow

A .NET library that uses C# Source Generators to automatically generate strongly-typed decorators and interceptors with compile-time safety and zero runtime overhead.

Overview

Strongflow lets you apply cross-cutting concerns (logging, caching, performance monitoring, authentication) to your methods using declarative attributes. Decorators are generated at compile-time via source generators, ensuring maximum performance with no reflection overhead.

Key Features

• Compile-Time Generation: All decorators generated via C# Source Generators
• Type-Safe: Full generic type support with compile-time checking
• Zero Runtime Overhead: No reflection, no dynamic proxies
• Async Support: First-class support for async/await and ValueTask
• Interceptor Chains: Chain multiple interceptors for sequential execution
• DI Integration: Built-in support for Microsoft.Extensions.DependencyInjection and Autofac

Installation

dotnet add package Strongflow.Abstractions
dotnet add package Strongflow.Generators

Quick Start

1. Define an Interceptor

using Strongflow.Abstractions;

public class LoggingInterceptor : IInterceptor
{
    public TResult Intercept<TFn, TArgs, TResult>(Calle<TFn, TArgs, TResult> call) where TFn : Delegate
    {
        var methodName = call.MethodInvocationTarget?.Name ?? "Unknown";
        Console.WriteLine($"Executing {methodName}");

        var result = call.Next();

        Console.WriteLine($"Completed {methodName}");
        return result;
    }

    public async ValueTask<TResult> InterceptAsync<TFn, TArgs, TResult>(
        CalleAsync<TFn, TArgs, TResult> call,
        CancellationToken cancellationToken = default)
    {
        var methodName = call.MethodInvocationTarget?.Name ?? "Unknown";
        Console.WriteLine($"Executing {methodName}");

        var result = await call.NextAsync();

        Console.WriteLine($"Completed {methodName}");
        return result;
    }
}

2. Use the Decorator

public class UserService
{
    private readonly IInterceptor _interceptor = new LoggingInterceptor();

    public int GetUserCount()
    {
        return DecoratedProcessor.Process(_interceptor, () =>
        {
            // Your business logic
            return 42;
        });
    }

    public async Task<string> GetUserNameAsync(int userId)
    {
        return await DecoratedProcessor.ProcessAsync(
            _interceptor,
            async () =>
            {
                await Task.Delay(100);
                return $"User {userId}";
            },
            CancellationToken.None);
    }
}

3. Chain Multiple Interceptors

public class CombinedInterceptor : IInterceptorForward
{
    private readonly IInterceptorForward? _next;

    public CombinedInterceptor(IInterceptorForward? next = null) => _next = next;

    public TResult Intercept<TFn, TArgs, TResult>(Calle<TFn, TArgs, TResult> call) where TFn : Delegate
    {
        Console.WriteLine("Before execution");
        var result = call.Next();
        Console.WriteLine("After execution");
        return result;
    }

    public ValueTask<TResult> InterceptAsync<TFn, TArgs, TResult>(
        CalleAsync<TFn, TArgs, TResult> call,
        CancellationToken cancellationToken = default)
    {
        return call.NextAsync();
    }

    public IInterceptorForward? ForwardΔ() => _next;
}

Dependency Injection

Microsoft.Extensions.DependencyInjection

using Microsoft.Extensions.DependencyInjection;
using Strongflow.Abstractions.MicrosoftDI;

var services = new ServiceCollection();

// Register a single interceptor (transient)
services.AddInterceptor<LoggingInterceptor>();

// Register with custom lifetime
services.AddInterceptor<CachingInterceptor>(ServiceLifetime.Singleton);

// Register with factory
services.AddInterceptor<CustomInterceptor>(
    sp => new CustomInterceptor(sp.GetRequiredService<ILogger>()),
    ServiceLifetime.Scoped);

var serviceProvider = services.BuildServiceProvider();

// Get interceptor from DI
var interceptor = serviceProvider.GetRequiredService<IInterceptor>();

// Or use the helper class
var interceptorProvider = new InterceptorServiceProvider(serviceProvider);
var result = interceptorProvider.Process(() => GetData());

Autofac

using Strongflow.Autofac;

var module = Strong.BuildModule("MyModule")
    .RegisterAssemblyTypes()
    .AsImplementedInterfaces()
    .EnableClassInterceptors()
    .InterceptedBy(typeof(LoggingInterceptor));

var builder = new ContainerBuilder();
builder.RegisterModule(module);
var container = builder.Build();

Project Structure

Strongflow.sln
├── Strongflow.Abstractions/          # Core interfaces (IInterceptor, Calle, CalleAsync)
├── Strongflow.Generator/             # Source generator implementation
├── Strongflow.Generators.Tests/      # Unit tests (200+)
├── Strongflow.Autofac/               # Autofac integration
├── Strongflow.Autofac.Tests/         # Autofac-specific tests
├── Strongflow.Benchmark/             # Performance benchmarks
└── Strongflow.Examples/              # Usage examples

Architecture

Core Components

• IInterceptor: Base interface for all interceptors with Intercept() and InterceptAsync() methods
• Calle<TFn, TArgs, TResult>: Call descriptor for synchronous calls - provides method metadata, arguments, chains via Next()
• CalleAsync<TFn, TArgs, TResult>: Call descriptor for async calls - chains via NextAsync()
• DecoratedProcessor: Main execution engine with Process() and ProcessAsync() methods

Interceptor Chain Pattern

Method Call → Interceptor 1 (Pre) → Interceptor 2 (Pre) → Actual Method → Interceptor 2 (Post) → Interceptor 1 (Post) → Result

Performance

Strongflow generates decorators at compile-time, resulting in:

• Zero reflection at runtime
• No dynamic proxies
• Direct IL code generation
• Inlining-friendly code that optimizes well with the JIT

Run benchmarks with:

dotnet run --project Strongflow.Benchmark/Strongflow.Benchmark.csproj --configuration Release

Testing

dotnet test

License

MIT License - see LICENSE file for details.