What is the AspectCore Project?

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 modularization of Asp.Net Core Development concept, using AspectCore makes it easier to build low-coupling and 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 from NugetAspectCore.Extensions.DependencyInjection package:

  PM>   Install-Package AspectCore.Extensions.DependencyInjection

• In general, you can use the abstractInterceptorAttribute Custom attribute class, which implements the IInterceptor interface. AspectCore implements interceptor configuration based on Attribute by default. Our custom interceptor looks like this:

  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");
          }
       }
   }

• DefinitionICustomServiceinterface and its implementation classCustomService:

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

• 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();
      }
  }

• RegisterICustomService, Next, configure the container to create the proxy type in ConfigureServices:

  public IServiceProvider ConfigureServices(IServiceCollection services)
  {
      services.AddTransient<icustomservice>();
      services.AddMvc();
      services.AddAspectCore();
      return services.BuildAspectCoreServiceProvider();
  }</icustomservice>

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

  PM> Install-Package AspectCore.Extensions.Configuration

  global interceptor. Use the overloaded method of AddAspectCore(Action<aspectcoreoptions>)</aspectcoreoptions>, where AspectCoreOptions provides InterceptorFactories to register a global interceptor:

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

  with constructor For the global interceptor of 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");
          }
      }
  }

  Modify the global interceptor registration:

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

  as the global interceptor of the service. Add in ConfigureServices:

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

  Modify the global interceptor registration:

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

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

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

  Specific global interceptor using wildcards:

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

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

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

  also supports global ignore configuration , also supports wildcards:

   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");
    });

• Dependency injection in interceptors. 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);
      }
  }</custominterceptorattribute>

  Constructor injection needs to make the interceptor as Service, in addition to the global interceptor, you can still use ServiceInterceptor Make the interceptor active from DI:

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

  Service locator mode. The interceptor context AspectContext can obtain the current Scoped's ServiceProvider:

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

• 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

  AspectCore provides the RegisterAspectCore extension method to register the services required by the dynamic proxy in Autofac's Container , and provide AsInterfacesProxy and AsClassProxy extension methods to enable the proxy of interface and class. 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());
  }</icustomservice></customservice>

Feedback on issues

If you have any questions, please submit an Issue to us.
AspectCore Project project address:

Finally. . .

Looking for a job, welcome to recommend .NET/.NET Core back-end development positions, located in Shanghai, please send a private message or email.

The above is the detailed content of What is the AspectCore Project?. For more information, please follow other related articles on the PHP Chinese website!