Was ist das AspectCore-Projekt?

Was ist AspectCore Project?

AspectCore Project ist eine leichte Aop-Lösung (Aspektorientierte Programmierung), die für die Asp.Net Core-Plattform geeignet ist. Sie folgt besser der Modularität der Asp.Net Core-Entwicklungsphilosophie AspectCore erleichtert die Erstellung von leicht skalierbaren Webanwendungen mit geringer Kopplung. AspectCore verwendet Emit, um einen effizienten dynamischen Proxy zu implementieren, ohne auf eine Aop-Bibliothek eines Drittanbieters angewiesen zu sein.

Beginnen Sie mit der Verwendung von AspectCore

• Starten Sie Visual Studio. Wählen Sie im Menü „Datei“ die Option „Neu“ > „Projekt“. Wählen Sie die Projektvorlage „ASP.NET Core-Webanwendung“ aus und erstellen Sie ein neues ASP.NET Core-Webanwendungsprojekt.

• Installieren Sie das AspectCore.Extensions.DependencyInjection-Paket von Nuget:

  PM>   Install-Package AspectCore.Extensions.DependencyInjection

• Im Allgemeinen können Sie die abstrakte InterceptorAttribute benutzerdefinierte Feature-Class verwenden , das die IInterceptor-Schnittstelle implementiert. AspectCore implementiert standardmäßig eine Attribute-basierte Interceptor-Konfiguration. Unser benutzerdefinierter Interceptor sieht so aus:

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

• Definieren Sie die ICustomServiceSchnittstelle und ihre ImplementierungsklasseCustomService:

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

• Injizieren Sie HomeController in ICustomService:

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

• RegistrierenICustomService und konfigurieren Sie dann den Container, um einen Proxy-Typ in ConfigureServices zu erstellen:

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

• Interceptor-Konfiguration. Installieren Sie zunächst das Paket AspectCore.Extensions.Configuration:

  PM> Install-Package AspectCore.Extensions.Configuration

  global interceptor. Verwenden Sie die überladene Methode von AddAspectCore(Action<AspectCoreOptions>), wobei AspectCoreOptions InterceptorFactories bereitstellt, um einen globalen Interceptor zu registrieren:

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

  globaler Interceptor mit Konstruktorparametern, fügen Sie einen Konstruktor mit Parametern in CustomInterceptorAttribute Interceptor hinzu:

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

  Ändern Sie die globale Interceptor-Registrierung:

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

  als globaler Interceptor des Dienstes. Fügen Sie ConfigureServices hinzu:

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

  Ändern Sie die globale Interceptor-Registrierung:

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

  Ein globaler Interceptor, der auf einen bestimmten Service oder Method einwirkt, wie im gezeigt Folgender Code: Globale Interceptoren, die auf Klassen mit dem Suffix Service wirken:

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

  Spezifische globale Interceptoren, die Platzhalter verwenden:

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

• in AspectCore NonAspectAttribute wird bereitgestellt, um zu verhindern, dass Service oder Method als Proxy verwendet wird:

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

  unterstützt auch globale Ignorierkonfiguration und Platzhalter:

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

• Abhängigkeitsinjektion in Abfangjäger. Unterstützt Eigenschaftsinjektion, Konstruktorinjektion und Service-Locator-Muster in Interceptoren.
  Attributinjektion: Wenn Sie über die Funktion public get and set Berechtigungsattributmarkierung [AspectCore.Abstractions.FromServices] (anders als Microsoft.AspNetCore.Mvc.FromServices) im Interceptor verfügen, können Sie das Attribut automatisch injizieren, z. B.:

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

  Für die Konstruktorinjektion ist der Interceptor als Service erforderlich. Zusätzlich zum globalen Interceptor kann der Interceptor weiterhin über den ServiceInterceptor:

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

  Service Locator-Modus aktiviert werden. Der Interceptor-Kontext AspectContext kann die aktuellen Scopeds ServiceProvider abrufen:

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

• mithilfe von Autofac und AspectCore. AspectCore unterstützt nativ die Integration von Autofac. Wir müssen die folgenden zwei Nuget-Pakete installieren:

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

  AspectCore stellt die RegisterAspectCore-Erweiterungsmethode bereit, um die vom dynamischen Proxy benötigten Dienste in Autofacs Container zu registrieren und und AsInterfacesProxy ermöglichen Proxys für Schnittstellen und Klassen. Ändern Sie AsClassProxy wie folgt: 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());
  }

Feedback

Wenn Sie Fragen haben, senden Sie uns bitte ein Problem.

AspectCore Project Projektadresse:

Endlich. . .

Auf der Suche nach einem Job? Gerne können Sie Stellen im Bereich .NET/.NET Core-Back-End empfehlen. Der Standort befindet sich in Shanghai.

Das obige ist der detaillierte Inhalt vonWas ist das AspectCore-Projekt?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!