Verwendung von PostSharp in .NET-Projekten

PostSharp ist eine Aspect-orientierte Programmierkomponente Framework, die hauptsächlich für die .NET-Entwicklung eingeführt wird Relevante Kenntnisse über Postsharp in der .NET-Entwicklung sowie einige allgemeine Aspektverarbeitungsvorgänge wie Protokollierung, Caching, Transaktionsverarbeitung, Ausnahmebehandlung und so weiter.

AOP (Aspektorientierte Programmierung) ist ein Programmier- generisches (Programmierparadigma), das die Hilfsfunktionen von Funktionen von der Geschäftslogik trennt. Reduzierung von Bedenken, damit das Programm höhere Modularitäts-Eigenschaften aufweist. AOP ist die spezifische Manifestation der aspektorientierten Softwareentwicklung (Aspektorientierte Softwareentwicklung) auf der Ebene der Codierungsimplementierung.

Wir wissen, dass Programmierer während des Codierungs- und Entwicklungsprozesses Entkopplung angestrebt haben, und AOP wurde auch für Entkopplung geboren. Die Einführung der AOP-Technologie kann unsere Codierung erheblich vereinfachen, die Menge des kopierten Codes reduzieren und die Verwaltung einheitlicher Teile des Codes erleichtern, z. B. Protokollierung, Caching, Transaktionsverarbeitung, Ausnahmebehandlung und andere häufig verwendete Verarbeitungen.

1. Einführung in das AOP-Framework

1) Einführung in die AOP-Technologie

Die AOP-Technologie verwendet eine Technologie namens „Cross-Cutting“ zum Profilieren Packen Sie das Innere des gekapselten Objekts aus und kapseln Sie das öffentliche Verhalten, das mehrere Klassen betrifft, in ein wiederverwendbares Modul und nennen Sie es „Aspekt“, also Aspekt. Der sogenannte „Aspekt“ besteht, einfach ausgedrückt, darin, die Logik oder Verantwortlichkeiten zu kapseln, die nichts mit dem Geschäft zu tun haben, sondern von den Geschäftsmodulen gemeinsam aufgerufen werden, um die Duplizierung von Code im System und die Kopplung zu reduzieren zwischen Modulen und erleichtern die zukünftige Zuverlässigkeit und Wartbarkeit. AOP stellt eine horizontale Beziehung dar, die die Attribute des Objekts kapselt, dann ist die aspektorientierte Programmiermethode wie eine scharfe Klinge die Botschaft darin. Die Schnittabschnitte sind die sogenannten „Aspekte“. Dann stellte es diese ausgeschnittenen Abschnitte mit unheimlichem Geschick wieder her und hinterließ keine Spuren.

Mithilfe der „Querschnitts“-Technologie unterteilt AOP das Softwaresystem in zwei Teile: Kernanliegen und Querschnittsanliegen. Der Hauptprozess der Geschäftsabwicklung ist das Kernanliegen, und der Teil, der wenig damit zu tun hat, ist das Querschnittsthema. Ein Merkmal von Querschnittsthemen ist, dass sie häufig an mehreren Stellen innerhalb des Kernanliegens auftreten, im Wesentlichen aber überall ähnlich sind. Zum Beispiel Autoritätsauthentifizierung, Protokollierung und Transaktionsverarbeitung. Die Rolle von Aop besteht darin, verschiedene Anliegen im System zu trennen und Kernanliegen von übergreifenden Anliegen zu trennen. Wie Adam Magee, leitender Lösungsarchitekt bei Avanade, sagte, besteht die Kernidee von AOP darin, „die Geschäftslogik im Anwendungsprogramm von den allgemeinen Diensten zu trennen, die Unterstützung bieten es.“

2) AOP-Nutzungsszenarien

AOP wird verwendet, um übergreifende Anliegen zu kapseln, die in den folgenden Szenarien verwendet werden können :

Authentifizierungsberechtigung

Caching-Caching

Context Passing Content Passing

Fehler Handling Fehlerbehandlung

Lazy Loading Lazy Loading

Debugging 🎜>Mance-Optimierung　Leistungsoptimierung

Persistenz　Persistenz

Ressource pooling Resource poolSyn

chr

onization　Synchronization

Transactions Transaction

3) PostSharp-Framework

PostSharp ist ein häufig verwendetes AOP-Framework, das zur Implementierung von AOP auf der .NET-Plattform verwendet wird. Die offizielle Website ist http://www.php.cn/. Die neueste Version ist derzeit 4.X, es handelt sich jedoch um eine kostenpflichtige AOP-Software.

PostSharp verwendet die statische Webmethode, um AOP zu implementieren. Seine Verbindungspunkte sind sehr umfangreich, einfach zu verwenden und im Vergleich zu anderen AOP-Frameworks auf einigen .NET-Plattformen ist es PostSharp leichtere Größe, aber die Funktionalität ist überhaupt nicht minderwertig.

Im Allgemeinen bringt die Verwendung von PostSharp die folgenden Vorteile:

• Trennung übergreifender Anliegen, wodurch die Klarheit und Wartbarkeit des Codes verbessert wird.

• Solange der Hilfsfunktionscode in Aspect geschrieben ist, werden der Arbeitsaufwand und der redundante Code bis zu einem gewissen Grad reduziert.

Natürlich gibt es einige Mängel bei der Verwendung von PostSharp. Die Hauptnachteile sind wie folgt:

• Erhöhte Schwierigkeit beim Debuggen.

• Im Vergleich zu Code ohne AOP ist die Betriebseffizienz geringer.

Im Vergleich zu diesen Mängeln kann die Verwendung von PostSharp die Entwicklungseffizienz erheblich verbessern, doppelten Code reduzieren und dadurch die Lesbarkeit und Wartbarkeit des Codes verbessern.

Darüber hinaus gibt es einige Open-Source-AOP-Komponenten auf GitHub. Die Top-Komponente ist beispielsweise KingAOP (http://www.php.cn/), aber weil es Um dies zu erreichen, wird die dynamische Methode verwendet, wie das konstruierte Objekt unten gezeigt wird.

dynamic helloWorld = new HelloWorld();
helloWorld.HelloWorldCall();

Obwohl es praktischer ist und angeblich den PostSharp-Nutzungsgewohnheiten ähnelt, ändert es die Art und Weise, wie Objekte erstellt werden, und ist nicht für Klassenobjekte geeignet Bearbeitung in allgemeinen Projekten. Daher bevorzuge ich immer noch die Verwendung von PostSharp für die AOP-Programmentwicklung.

2. Verwendung des PostSharp-Frameworks

1) Bereiten Sie die Kompilierungsumgebung von PostSharp vor

Die aktuelle Version von PostSharp ist 4.x habe ich von der offiziellen Website heruntergeladen und verwendet, aber „Fehler beim Herstellen der Verbindung zum Pipe-Server. Weitere Informationen finden Sie in den vorherigen Warnungen.“ Später habe ich einfach Version 3.x verwendet , aber es hat normal funktioniert, haha. PostSharp ist ein Plug-in, das auf VS

installiert

werden kann. Nach der Installation wird der Menüspalte von VS ein PostSharp-Menüelement hinzugefügt, wie unten gezeigt.

Wenn Sie die PostSharp-Funktion in einem allgemeinen Projekt verwenden müssen, verwenden Sie auf der Optionsseite [PostSharp] der Projekteigenschaften die Option [PostSharp zu diesem Projekt hinzufügen] zum Hinzufügen PostSharp zum Projekt verwenden.

Nach dem Hinzufügen wird das PostSharp-Plug-In-Eingabeaufforderungsdialogfeld angezeigt, in dem Sie aufgefordert werden, das entsprechende PostSharp-Paket und andere Inhalte hinzuzufügen, wie unten gezeigt.

Nach Abschluss können Sie PostSharp-bezogene Klassen im Projekt verwenden.

2) AOP-Aspektverarbeitung von PostSharp hinzufügen

Es besteht allgemein Einigkeit darüber, dass die Benennung jeder Aspektklasse in der Form „XXXAttribute“ erfolgen muss ". Unter ihnen ist „XXX“ der Name dieses Aspekts. PostSharp bietet eine Fülle integrierter „Basisaspekte“, die wir

erben

können, darunter hier „OnMethodBoundaryAspect“. Dieser Aspekt stellt Verbindungspunktmethoden wie das Eingeben und Beenden von bereit . Darüber hinaus muss „[Serialisierbar]“ für Aspect festgelegt werden, was mit PostSharps internem Lebenszyklus Management von Aspect zusammenhängt. Der Code der Aspect-Klasse des Protokolls lautet wie folgt.

Der Klassencode für die Ausnahmebehandlung lautet wie folgt.

    [Serializable]    public class LogAttribute : OnMethodBoundaryAspect
    {        public override void OnEntry(MethodExecutionArgs args)
        {
            Console.WriteLine(Environment.NewLine);

            Console.WriteLine("Entering [ {0} ] ...", args.Method);            base.OnEntry(args);
        }        public override void OnExit(MethodExecutionArgs args)
        {
            Console.WriteLine("Leaving [ {0} ] ...", args.Method);            base.OnExit(args);
        }
    }

Der Aspect-Klassencode für die Zeitverarbeitung lautet wie folgt.

    [Serializable]    public class ExceptionAttribute : OnExceptionAspect
    {        public override void OnException(MethodExecutionArgs args)
        {
            Console.WriteLine(String.Format("Exception in :[{0}] , Message:[{1}]", args.Method, args.Exception.Message));
            args.FlowBehavior = FlowBehavior.Continue;            base.OnException(args);
        }
    }

Der Aspect-Klassencode für die Transaktionsverarbeitung lautet wie folgt.

    [Serializable]
    [MulticastAttributeUsage(MulticastTargets.Method)]    public class TimingAttribute : PostSharp.Aspects.OnMethodBoundaryAspect
    {
        [NonSerialized]
        Stopwatch _StopWatch;        public override void OnEntry(PostSharp.Aspects.MethodExecutionArgs args)
        {
            _StopWatch = Stopwatch.StartNew();            base.OnEntry(args);
        }        public override void OnExit(PostSharp.Aspects.MethodExecutionArgs args)
        {
            Console.WriteLine(string.Format("[{0}] took {1}ms to execute",              new StackTrace().GetFrame(1).GetMethod().Name,
                _StopWatch.ElapsedMilliseconds));            base.OnExit(args);
        }
    }

Das Folgende ist der Aspektverarbeitungscode mehrerer Aspektklassen, wie unten gezeigt.

    [Serializable]
    [AspectTypeDependency(AspectDependencyAction.Order, AspectDependencyPosition.After, typeof(LogAttribute))]    public class RunInTransactionAttribute : OnMethodBoundaryAspect
    {
        [NonSerialized]
        TransactionScope TransactionScope;        public override void OnEntry(MethodExecutionArgs args)
        {            this.TransactionScope = new TransactionScope(TransactionScopeOption.RequiresNew);
        }        public override void OnSuccess(MethodExecutionArgs args)
        {            this.TransactionScope.Complete();
        }        public override void OnException(MethodExecutionArgs args)
        {
            args.FlowBehavior = FlowBehavior.Continue;
            Transaction.Current.Rollback();
            Console.WriteLine("Transaction Was Unsuccessful!");
        }        public override void OnExit(MethodExecutionArgs args)
        {            this.TransactionScope.Dispose();
        }
    }

Aus dem Obigen können wir ersehen, dass die herkömmliche Ausnahmebehandlung und Protokollverarbeitung über Attribute verarbeitet wurde und nur noch der spezifische Geschäftslogikcode enthalten ist. Dies verbessert die Lesbarkeit des Codes erheblich und ist prägnant und klar.

        [Exception]
        [Log]        static void Calc()
        {            throw new pideByZeroException("A Math Error Occured...");
        }

        [Log, Timing]        static void LongRunningCalc()
        {            //wait for 1000 miliseconds
            Thread.Sleep(1000);
        }

Führen Sie den obigen Code-Funktionsaufruf aus. Wir können den spezifischen Ergebnisinhalt im Ausgabeprotokoll sehen.

Entering [ Void Calc() ] ...
“System.pideByZeroException”类型的第一次机会异常在 PostSharpExample.exe 中发生
Exception in :[Void Calc()] , Message:[A Math Error Occured...]
Leaving [ Void Calc() ] ...


Entering [ Void LongRunningCalc() ] ...
Leaving [ Void LongRunningCalc() ] ...
[LongRunningCalc] took 1002ms to execute

这样，通过声明的方式，就实现了常规日志 、异常的处理，当然实际项目上使用日志、异常处理的这些代码肯定会更加复杂一些，不过小例子已经实现了切面逻辑的分离处理了，尘归尘、土归土，一切都是那么的简洁安静了。

 

Das obige ist der detaillierte Inhalt vonVerwendung von PostSharp in .NET-Projekten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!