A brief discussion on AspectCore_Practical skills-C#.Net Tutorial-php.cn

This article mainly introduces the Asp.Net Core lightweight Aop solution: AspectCore. Friends who need it can refer to it

What is AspectCore Project?

AspectCore Project is a lightweight Aop (Aspect-oriented programming) solution suitable for the Asp.Net Core platform. It better follows the modular development concept of Asp.Net Core. Using AspectCore can be more Easily build low-coupling, easily scalable web applications. AspectCore uses Emit to implement efficient dynamic proxy without relying on any third-party Aop library.

Start using AspectCore

Start Visual Studio. From the File menu, choose New > Project. Select the ASP.NET Core Web Application project template and create a new ASP.NET Core Web Application project.

Install AspectCore.Extensions.DependencyInjection package from Nuget:
##PM> Install-Package AspectCore.Extensions.DependencyInjection
In general, you can use the abstract InterceptorAttribute custom attribute class, which implements the IInterceptor
interface. AspectCore implements Attribute-based interceptor configuration by default. Our custom interceptor looks like the following:

public class CustomInterceptorAttribute : InterceptorAttribute
{
  public async override Task Invoke(IAspectContext context, AspectDelegate next)
  {
    try
    {
      Console.WriteLine("Before service call");
      await next(context);
    }
    catch (Exception)
    {
      Console.WriteLine("Service threw an exception!");
      throw;
    }
    finally
    {
      Console.WriteLine("After service call");
    }
   }
 }

Copy after login

Define the ICustomService interface and its implementation class CustomService:

public interface ICustomService
{
  [CustomInterceptor]
  void Call();
}
public class CustomService : ICustomService
{
  public void Call()
  {
    Console.WriteLine("service calling...");
  }
}

Copy after login

Inject ICustomService in HomeController:

public class HomeController : Controller
{
  private readonly ICustomService _service;
  public HomeController(ICustomService service)
  {
    _service = service;
  }
  public IActionResult Index()
  {
    _service.Call();
    return View();
  }
}

Copy after login

public IServiceProvider ConfigureServices(IServiceCollection services)
{
  services.AddTransient<ICustomService, CustomService>();
  services.AddMvc();
  services.AddAspectCore();
  return services.BuildAspectCoreServiceProvider();
}

Copy after login

Interceptor configuration. First install the AspectCore.Extensions.Configuration package:

PM> Install-Package AspectCore.Extensions.Configuration

Copy after login

Global interceptor. Use the

overloaded method of AddAspectCore(Action), where AspectCoreOptions provides InterceptorFactories to register the global interceptor:

 services.AddAspectCore(config =>
 {
   config.InterceptorFactories.AddTyped<CustomInterceptorAttribute>();
 });

Copy after login

Global interceptor with constructor parameters, add a constructor with parameters in

CustomInterceptorAttribute:

public class CustomInterceptorAttribute : InterceptorAttribute
{
  private readonly string _name;
  public CustomInterceptorAttribute(string name)
  {
    _name = name;
  }
  public async override Task Invoke(AspectContext context, AspectDelegate next)
  {
    try
    {
      Console.WriteLine("Before service call");
      await next(context);
    }
    catch (Exception)
    {
      Console.WriteLine("Service threw an exception!");
      throw;
    }
    finally
    {
      Console.WriteLine("After service call");
    }
  }
}

Copy after login

Modify global interceptor registration:

services.AddAspectCore(config =>
{
   config.InterceptorFactories.AddTyped<CustomInterceptorAttribute>(args: new object[] { "custom" });
});

Copy after login

As a global interceptor for the service. Add in ConfigureServices:

services.AddTransient<CustomInterceptorAttribute>(provider => new CustomInterceptorAttribute("service"));

Copy after login

Modify global interceptor registration:

services.AddAspectCore(config =>
{
  config.InterceptorFactories.AddServiced<CustomInterceptorAttribute>();
});

Copy after login

acts on a specific Service or Method Global interceptor, the following code demonstrates the global interceptor acting on classes with the Service suffix:

services.AddAspectCore(config =>
{
  config.InterceptorFactories.AddTyped<CustomInterceptorAttribute>(method => method.DeclaringType.Name.EndsWith("Service"));
});

Copy after login

Specific global interception using the

wildcard character Device:

services.AddAspectCore(config =>
{
  config.InterceptorFactories.AddTyped<CustomInterceptorAttribute>(PredicateFactory.ForService("*Service"));
});

Copy after login

Provide NonAspectAttribute in AspectCore to prevent Service or Method from being proxied:

[NonAspect]
public interface ICustomService
{
  void Call();
}

Copy after login

Supported at the same time The configuration is ignored globally and wildcards are also supported:

 services.AddAspectCore(config =>
 {
   //App1命名空间下的Service不会被代理
   config.NonAspectOptions.AddNamespace("App1");
   //最后一级为App1的命名空间下的Service不会被代理
   config.NonAspectOptions.AddNamespace("*.App1");
   //ICustomService接口不会被代理
   config.NonAspectOptions.AddService("ICustomService");
   //后缀为Service的接口和类不会被代理
   config.NonAspectOptions.AddService("*Service");
   //命名为Query的方法不会被代理
   config.NonAspectOptions.AddMethod("Query");
   //后缀为Query的方法不会被代理
   config.NonAspectOptions.AddMethod("*Query");
 });

Copy after login

Dependency Injection in the interceptor. Supports property injection, constructor injection and service locator patterns in interceptors. Property injection, property tags with public get and
set permissions in the interceptor [AspectCore.Abstractions.FromServices] (different from Microsoft.AspNetCore.Mvc. FromServices) feature, you can automatically inject this property, such as:

public class CustomInterceptorAttribute : InterceptorAttribute
{
  [AspectCore.Abstractions.FromServices]
  public ILogger<CustomInterceptorAttribute> Logger { get; set; }
  public override Task Invoke(AspectContext context, AspectDelegate next)
  {
    Logger.LogInformation("call interceptor");
    return next(context);
  }
}

Copy after login

Constructor injection needs to make the interceptor as a Service. In addition to the global interceptor, it can still be Use ServiceInterceptor to enable the interceptor to be activated from DI:

public interface ICustomService
{
  [ServiceInterceptor(typeof(CustomInterceptorAttribute))]
  void Call();
}

Copy after login

Service Locator pattern. The interceptor context AspectContext can obtain the current Scoped ServiceProvider:

public class CustomInterceptorAttribute : InterceptorAttribute
{
  public override Task Invoke(AspectContext context, AspectDelegate next)
  {
    var logger = context.ServiceProvider.GetService<ILogger<CustomInterceptorAttribute>>();
    logger.LogInformation("call interceptor");
    return next(context);
  }
}

Copy after login

Using Autofac and AspectCore. AspectCore natively supports integrating Autofac. We need to install the following two nuget packages:

PM> Install-Package Autofac.Extensions.DependencyInjection
PM> Install-Package AspectCore.Extensions.Autofac

Copy after login

AspectCore provides the RegisterAspectCore extension method to register the services required by the dynamic proxy in the Autofac Container and provide The AsInterfacesProxy and AsClassProxy extension methods enable proxies for interfaces and classes. Modify the ConfigureServices method to:

public IServiceProvider ConfigureServices(IServiceCollection services)
{
  services.AddMvc();
  var container = new ContainerBuilder();
  container.RegisterAspectCore();
  container.Populate(services);
  container.RegisterType<CustomService>().As<ICustomService>().InstancePerDependency().AsInterfacesProxy();

  return new AutofacServiceProvider(container.Build());
}

Copy after login

The above is the detailed content of A brief discussion on AspectCore_Practical skills. For more information, please follow other related articles on the PHP Chinese website!