Qu'est-ce que le projet AspectCore ?

Qu'est-ce que le projet AspectCore ?

Le projet AspectCore est une solution Aop légère (programmation orientée aspect) adaptée à la plate-forme Asp.Net Core. Elle suit mieux la modularité du concept de développement Asp.Net Core, en utilisant. AspectCore facilite la création d'applications Web à faible couplage et facilement évolutives. AspectCore utilise Emit pour implémenter un proxy dynamique efficace sans recourir à une bibliothèque Aop tierce.

Commencez à utiliser AspectCore

• Lancez Visual Studio. Dans le menu Fichier, choisissez Nouveau > Projet. Sélectionnez le modèle de projet d'application Web ASP.NET Core et créez un nouveau projet d'application Web ASP.NET Core.

• Installez le package AspectCore.Extensions.DependencyInjection à partir de Nuget :

  PM>   Install-Package AspectCore.Extensions.DependencyInjection

  Copier après la connexion

• En général, vous pouvez utiliser la classe de fonctionnalités personnalisée abstraite InterceptorAttribute , qui implémente l'interface IInterceptor. AspectCore implémente par défaut la configuration de l'intercepteur basée sur Attribute. Notre intercepteur personnalisé ressemble à ceci :

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

  Copier après la connexion

• Définir l'ICustomServiceinterface et sa classe d'implémentationCustomService :

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

  Copier après la connexion

• Injectez HomeController dans ICustomService :

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

  Copier après la connexion

• RegisterICustomService, puis configurez le conteneur pour créer un type de proxy dans ConfigureServices :

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

  Copier après la connexion

• Configuration de l'intercepteur. Installez d'abord le package AspectCore.Extensions.Configuration :

  PM> Install-Package AspectCore.Extensions.Configuration

  Copier après la connexion

  global interceptor. Utilisez la méthode surchargée de AddAspectCore(Action<AspectCoreOptions>), où AspectCoreOptions fournit InterceptorFactories pour enregistrer un intercepteur global :

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

  Copier après la connexion

  intercepteur global avec des paramètres de constructeur, ajoutez un constructeur avec des paramètres dans CustomInterceptorAttribute Intercepteur :

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

  Copier après la connexion

  Modifier l'enregistrement de l'intercepteur global :

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

  Copier après la connexion

  comme intercepteur global du service. Ajoutez ConfigureServices :

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

  Copier après la connexion

  Modifier l'enregistrement de l'intercepteur global :

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

  Copier après la connexion

  Un intercepteur global qui agit sur un Service ou un Method spécifique, comme indiqué dans le code suivant Intercepteurs globaux qui agissent sur les classes avec le suffixe Service :

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

  Copier après la connexion

  Intercepteurs globaux spécifiques utilisant des caractères génériques :

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

  Copier après la connexion

• dans AspectCore NonAspectAttribute est fourni pour empêcher Service ou Method d'être proxy :

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

  Copier après la connexion

  prend également en charge la configuration d'ignorance globale et les caractères génériques :

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

  Copier après la connexion

• Injection de dépendances dans intercepteurs. Prend en charge l'injection de propriétés, l'injection de constructeurs et les modèles de localisateur de services dans les intercepteurs.
  Injection d'attribut, si vous disposez de la fonctionnalité public get and set marque d'attribut d'autorisation [AspectCore.Abstractions.FromServices] (différente de Microsoft.AspNetCore.Mvc.FromServices) dans l'intercepteur, vous pouvez automatiquement injecter l'attribut, tel que :

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

  Copier après la connexion

  constructor Injection nécessite l'intercepteur comme Service En plus de l'intercepteur global, l'intercepteur peut toujours être activé à partir de DI en utilisant ServiceInterceptor :

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

  Copier après la connexion

  mode localisateur de service. Le contexte de l'intercepteur AspectContext peut obtenir le Scoped actuel 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);
      }
  }

  Copier après la connexion

• en utilisant Autofac et AspectCore. AspectCore prend en charge nativement l'intégration d'Autofac. Nous devons installer les deux packages nuget suivants :

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

  Copier après la connexion

  AspectCore fournit la méthode d'extension RegisterAspectCore pour enregistrer les services requis par le proxy dynamique dans Container d'Autofac et fournir et AsInterfacesProxy activent les proxys pour les interfaces et les classes. Modifiez AsClassProxy comme suit : ConfigureServices

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

  Copier après la connexion

Adresse du projet AspectCore Project :

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!