Une brève discussion sur les compétences AspectCore_Practical

Cet article présente principalement la solution Aop légère Asp.Net Core : AspectCore, les amis qui en ont besoin peuvent s'y référer

Qu'est-ce que le projet AspectCore ?

AspectCore Project est une solution Aop (programmation orientée aspect) légère adaptée à la plate-forme Asp.Net Core. Elle suit mieux le concept de développement modulaire d'Asp.Net Core. L'utilisation d'AspectCore peut être plus facilement construite à faible couplage. applications Web facilement évolutives. AspectCore utilise Emit pour implémenter un proxy dynamique efficace sans recourir à une bibliothèque Aop tierce.

Démarrez Visual Studio à l'aide d'AspectCore

. 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.

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

• PM>

En général, vous pouvez utiliser la classe d'attributs personnalisés abstraite InterceptorAttribute, qui implémente l'interface IInterceptor

• . AspectCore implémente par défaut la configuration de l'intercepteur basée sur les attributs. Notre intercepteur personnalisé ressemble à ceci :

Définissez l'interface ICustomService et sa classe d'implémentation CustomService :

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

Injecter ICustomService dans HomeController :

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

Enregistrez ICustomService, puis configurez le type de proxy créé dans le conteneur ConfigureServices :

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

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

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

intercepteur global. Utilisez le

PM> Install-Package AspectCore.Extensions.Configuration

de

pour surcharger la méthode AddAspectCore(Actioncf55c8c03f0256412fce639ce72d0b5d), où AspectCoreOptions fournit InterceptorFactories pour enregistrer un intercepteur global :

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

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

 :

CustomInterceptorAttribute

Modifiez l'enregistrement global de l'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");
    }
  }
}

Agit comme un intercepteur global pour le service. Ajoutez ConfigureServices :

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

Modifier l'enregistrement global de l'intercepteur :

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

pour agir sur des paramètres globaux spécifiques. intercepteur pour un service ou une méthode. Le code suivant montre l'intercepteur global agissant sur les classes avec le suffixe Service :

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

Utilisez le

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

wildcard :

Fournissez NonAspectAttribute dans AspectCore pour empêcher le service ou la méthode d'être proxy :

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

prend également en charge la configuration globale ignorée et les caractères génériques :

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

Injection de dépendances dans l'intercepteur

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

. Prend en charge l'

injection de propriété, l'injection de constructeur et les modèles de localisateur de service dans les intercepteurs. Injection d'attribut, si vous avez la balise d'attribut [] (différente de ) avec les autorisations publiques get et
set dans l'intercepteur, vous pouvez automatiquement injecter l'attribut, tel que : AspectCore.Abstractions.FromServicesMicrosoft.AspNetCore.Mvc.FromServices

L'injection de constructeur nécessite que l'intercepteur soit utilisé en tant que service. En plus de l'intercepteur global, le ServiceInterceptor peut toujours être utilisé pour activer l'intercepteur depuis DI :

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

Mode localisateur de services. Le contexte d'intercepteur AspectContext peut obtenir le Scoped ServiceProvider actuel :

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

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

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

AspectCore fournit la méthode d'extension RegisterAspectCore pour enregistrer les services requis pour les agents dynamiques dans Autofac. Container. Et fournissez les méthodes d’extension AsInterfacesProxy et AsClassProxy pour activer le proxy de l’interface et de la classe. Modifiez la méthode ConfigureServices en :

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

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!