ZibStack.NET.Aop 3.2.2

ZibStack.NET.Aop

AOP framework for .NET 8+ using C# interceptors — define aspects that run before, after, or around any method at compile time. No runtime proxy, no reflection.

Install

dotnet add package ZibStack.NET.Aop

Built-in Aspects

All registered automatically by AddAop():

Bulk Apply (no attributes needed)

Apply aspects to entire namespaces, interfaces, or base classes — no per-method attributes required:

public sealed class AopConfig : IAopConfigurator
{
    public void Configure(IAopBuilder b)
    {
        // Log every public method in a namespace — zero attributes on classes
        b.Apply<LogAttribute>(to => to
            .Namespace("MyApp.Services")
            .PublicMethods()
        );

        b.Apply<TraceAttribute>(to => to
            .Namespace("MyApp.Services")
            .PublicMethods()
        );

        b.Apply<CacheAttribute>(to => to
            .Implementing<IRepository>()
            .PublicMethods()
        , c => c.DurationSeconds = 120);

        b.Apply<RetryAttribute>(to => to
            .Namespace("MyApp.External")
            .MethodsWhere(m => m.IsAsync)
        , r => r.MaxAttempts = 5);
    }
}

Selectors: .Namespace(), .Implementing<T>(), .DerivedFrom<T>(), .ClassesWhere(), .MethodsWhere(), .PublicMethods(), .Except<T>().

Works with interfaces, generics, overloads, diamond inheritance, and DI dispatch.

Optional (require external packages): [PollyRetry] (Polly.Core), [HybridCache] (Microsoft.Extensions.Caching.Hybrid).

// One attribute per concern:
[Trace]
[Log]
[Retry(MaxAttempts = 3, Handle = new[] { typeof(HttpRequestException) })]
[Cache(KeyTemplate = "order:{id}", DurationSeconds = 60)]
[Metrics]
public async Task<Order> GetOrderAsync(int id) { ... }

Setup

using ZibStack.NET.Aop;

builder.Services.AddAop();                       // registers all built-in handlers
builder.Services.AddTransient<MyHandler>();       // your own handlers

var app = builder.Build();
app.Services.UseAop();                           // bridges DI into the aspect runtime — required

Custom aspects

[AspectHandler(typeof(TimingHandler))]
public class TimingAttribute : AspectAttribute { }

public class TimingHandler : IAspectHandler
{
    public void OnBefore(AspectContext ctx)
        => Console.WriteLine($"Before {ctx.MethodName}");
    public void OnAfter(AspectContext ctx)
        => Console.WriteLine($"After {ctx.MethodName} in {ctx.ElapsedMilliseconds}ms");
    public void OnException(AspectContext ctx, Exception ex)
        => Console.WriteLine($"Error in {ctx.MethodName}: {ex.Message}");
}

// Apply anywhere:
[Timing]
public Order GetOrder(int id) { ... }

Also supported: IAroundAspectHandler<T> (strongly-typed), IAsyncAspectHandler, IAsyncAroundAspectHandler, dual sync+async interfaces, class-level aspects, multi-aspect stacking with Order.

Documentation

Full documentation: mistykuu.github.io/ZibStack.NET/packages/aop/