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.
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());
}AspectCore Project Projektadresse:
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!
Was sind die ASP-Entwicklungstools?
So schreiben Sie MySQL-Prüfeinschränkungen
So setzen Sie Chinesisch in Eclipse ein
Einführung in Wagenrücklauf- und Zeilenvorschubzeichen in Java
So formatieren Sie die Festplatte unter Linux
Methode zur Erstellung von Intouch-Berichten
So führen Sie HTML-Code in vscode aus
WLAN zeigt an, dass keine IP zugewiesen ist
