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

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

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

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

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

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

  PM> Install-Package AspectCore.Extensions.Configuration

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

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

  Modifier l'enregistrement de l'intercepteur global :

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

  comme intercepteur global du service. Ajoutez ConfigureServices :

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

  Modifier l'enregistrement de l'intercepteur global :

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

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

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

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

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

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

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

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

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

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

• 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

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

Commentaires

Si vous avez des questions, veuillez nous soumettre un problème.

Adresse du projet AspectCore Project :

Enfin. . .

Vous recherchez un emploi ? Bienvenue pour recommander des postes de développement back-end .NET/.NET Core. L'emplacement est à Shanghai. Vous pouvez envoyer un message privé ou un e-mail.

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!