NexusAOP 1.0.1

NexusAop is a powerful and flexible library for reflection and aspect-oriented programming (AOP) in .NET 5.0. This library enables developers to easily apply cross-cutting concerns to their applications by utilizing custom attributes. With NexusAop, you can interrupt method executions, perform specific actions, and retrieve results seamlessly.

Table Of Content

1. Features
2. Get It Started
3. Cache Attribute Example
4. Contributions
5. License

Features

1. Aspect-Oriented Programming (AOP): NexusAop empowers developers to embrace the principles of AOP by providing a straightforward mechanism for applying cross-cutting concerns using custom attributes.
2. Method Interruption: Leverage the NextAsync() method to interrupt the execution of a method and perform specific actions before allowing the method to continue. This allows for dynamic and context-aware behavior in your applications.
3. Result Retrieval: Utilize the ExecuteAndGetResultAsync() method to retrieve the result of the related method. This feature is particularly useful when you need to capture and manipulate the output of a method in a controlled manner.
4. Custom Attributes: Easily create and apply custom attributes to your methods, enabling a clean and declarative way to define aspects. Custom attributes in NexusAop serve as the building blocks for weaving cross-cutting concerns into your application.
5. .NET 5.0 Compatibility: NexusAop is designed to seamlessly integrate with .NET 5.0.

Get It Started

To start using NexusAop in your .NET 5.0 project, follow these simple steps:

1. Install the Package:

dotnet add package NexusAop 2. Service Implementation:

serviceCollection.AddSingletonWithCustomAop<ITestService, TestService>();

3. Apply Custom Attributes:

Decorate your methods with custom attributes to define the desired cross-cutting concerns.

[CustomAspect]
public async Task<int> MyMethodAsync()
{
    // Your method implementation
}

4. Integrate Aspect-Oriented Behavior:

Use the provided methods such as NextAsync() and ExecuteAndGetResultAsync() within your custom aspects to influence the method execution flow.

public class CustomAspectAttribute : NexusAopAttribute
{
    public override async Task ExecuteAsync(NexusAopContext context)
    {
        // Perform actions before the method execution

        // Proceed with the execution of the target method
        var result = await context.NextAsync();

        // User-defined logic after the target method

        // Get the result if you needed
        var setResult= await context.ExecuteAndGetResultAsync();

        return result;
    }
}

5. Build and Run:

Build your project, and NexusAop will seamlessly weave the specified aspects into your methods during runtime.

Cache Attribute Example

public class CacheMethodAttribute : NexusAopAttribute
    {
        public CacheMethodAttribute(
                int ttlAsSecond)
        {
            Ttl = TimeSpan.FromSeconds(ttlAsSecond);
        }

        public CacheMethodAttribute()
        {
            Ttl = null;
        }

        public TimeSpan? Ttl { get; set; }

        public override async Task ExecuteAsync(NexusAopContext context)
        {
            if (!CheckMethodCacheable(context.TargetMethod))
            {
                return;
            }
            var cacheKey = GetCacheKey(context.TargetMethod, context.TargetMethodsArgs);
            var result = GetResult(cacheKey);

            if (result != null)
            {
                context.Result= result;
                return;
            }

            result = await context.ExecuteAndGetResultAsync();
            await SetCacheAsync(context.TargetMethod, context.TargetMethodsArgs,result);
        }

        // ...
        // see CacheMethodAttribute.cs in /Samples/Cache for other logics
        // ...
  }

Contributions

Contributions are welcome! If you encounter any issues or have suggestions for improvements, please feel free to create an issue or submit a pull request.

License

This project is licensed under the BSD 3-Clause License.