Utilisation de PostSharp dans les projets .NET

PostSharp est un framework de programmation orientée aspect (ou orienté aspect) de Asp, adapté au développement .NET. Cet article présente. Connaissance pertinente de Postsharp dans le développement .NET, ainsi que de certaines opérations de traitement d'aspects courants telles que la journalisation, la mise en cache, le traitement des transactions, la gestion des exceptions et ainsi de suite.

AOP (Aspect-Oriented Programming) est un programmation générique (paradigme de programmation) qui sépare les fonctions auxiliaires des fonctions de la logique métier. Son objectif Il sépare les fonctions croisées. réduire les problèmes afin que le programme ait des caractéristiques de modularité plus élevées. L'AOP est la manifestation spécifique du développement logiciel orienté aspect (Aspect-Oriented Software Development) au niveau de l'implémentation du codage.

Nous savons que le découplage est ce que les programmeurs recherchent pendant le processus de codage et de développement, et AOP est également né pour le découplage. L'introduction de la technologie AOP peut grandement simplifier notre codage, réduire la quantité de code copié et faciliter la maintenance de parties unifiées du code, telles que la journalisation, la mise en cache, le traitement des transactions, la gestion des exceptions et d'autres traitements couramment utilisés.

1. Introduction au framework AOP

1) Introduction à la technologie AOP

La technologie AOP utilise une technologie dite « transversale » pour profiler Déballez l'intérieur de l'objet encapsulé et encapsulez le comportement public qui affecte plusieurs classes dans un module réutilisable, et nommez-le "Aspect", c'est-à-dire aspect. Le soi-disant "aspect", en termes simples, consiste à encapsuler la logique ou les responsabilités qui n'ont rien à voir avec le métier mais qui sont appelées conjointement par les modules métier, de manière à réduire la duplication de code dans le système, à réduire le couplage entre les modules et faciliter la fiabilité future et la maintenabilité. AOP représente une relation horizontale. Si "l'objet" est un cylindre creux, qui encapsule les attributs et le comportement de l'objet ; alors la méthode de programmation orientée aspect est comme une lame tranchante. Coupez ces cylindres creux pour obtenir. le message à l'intérieur. Les sections coupées sont ce qu'on appelle les « aspects ». Puis il a restauré ces sections coupées avec une habileté incroyable, sans laisser de trace.

Grâce à la technologie « transversale », AOP divise le système logiciel en deux parties : les préoccupations centrales et les préoccupations transversales. Le processus principal de traitement des affaires est la préoccupation centrale, et la partie qui a peu de relation avec lui est la préoccupation transversale. L’une des caractéristiques des préoccupations transversales est qu’elles se manifestent souvent à plusieurs endroits au sein de la préoccupation centrale, mais qu’elles sont fondamentalement similaires partout. Tels que l'authentification des autorités, la journalisation et le traitement des transactions. Le rôle de l'Aop est de séparer les différentes préoccupations du système, en séparant les préoccupations centrales et les préoccupations transversales. Comme l'a déclaré Adam Magee, architecte de solutions senior chez Avanade, l'idée centrale d'AOP est de « séparer la logique métier du programme d'application des services généraux qui fournissent un support pour "

2) Scénarios d'utilisation de l'AOP

AOP est utilisé pour résumer des préoccupations transversales, qui peuvent être utilisées dans les scénarios suivants :

Autorisation d'authentification

Mise en cache

Transmission de contenu en passant par le contexte

Gestion des erreursdling Gestion des erreurs

Chargement paresseux Chargement paresseux

Débogage 🎜>Optimisation de la mance　Optimisation des performances

Persistance　Persistance

Ressource mutualisation Pool de ressourcesSyn

chr

onisation　Synchronisation

Transactions Transaction

3) Framework PostSharp

PostSharp est un framework utilisé pour implémenter AOP sur la plateforme .NET est un framework AOP relativement couramment utilisé. Le site officiel est http://www.php.cn/. . La dernière version est actuellement la 4.X, mais il s'agit d'un logiciel AOP payant.

PostSharp utilise la méthode de tissage statique pour implémenter AOP. Ses points de connexion sont très riches, faciles à utiliser, et comparés aux autres frameworks AOP sur certaines plateformes .NET, PostSharp l'est. une ampleur plus légère, mais la fonctionnalité n'est pas du tout inférieure.

En général, l'utilisation de PostSharp apportera les avantages suivants :

• Séparer séparément les préoccupations transversales améliore la clarté et la maintenabilité du code.

• Tant que le code de la fonction auxiliaire est écrit en Aspect, la charge de travail et le code redondant sont réduits dans une certaine mesure.

Bien sûr, l'utilisation de PostSharp présente quelques inconvénients. Les principaux inconvénients sont les suivants :

• Augmente la difficulté du débogage.

• Par rapport au code sans AOP, l'efficacité de fonctionnement est réduite.

Cependant, les défauts ne sont pas cachés. Par rapport à ces défauts, l'utilisation de PostSharp peut grandement améliorer l'efficacité du développement, réduire le code en double, améliorant ainsi la lisibilité et la maintenabilité du code.

De plus, il existe des composants AOP open source sur GitHub. Par exemple, le premier est KingAOP (http://www.php.cn/), mais parce que c'est le cas. utilise une manière dynamique pour y parvenir, comme son objet construit est illustré ci-dessous.

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

Par conséquent, bien que cela soit plus pratique et serait similaire aux habitudes d'utilisation de PostSharp, cela change la façon dont les objets sont créés et ne convient pas aux objets de classe. traitement dans les projets généraux. Par conséquent, je préfère toujours utiliser PostSharp pour le développement de programmation AOP.

2. Utilisation du framework PostSharp

1) Préparer l'environnement de compilation de PostSharp

La version actuelle de PostSharp est 4.x, je l'ai téléchargé depuis le site officiel et je l'ai utilisé, mais "Une erreur de connexion au serveur pipe. Voir les avertissements précédentspour plus de détails s'est souvent produite plus tard, j'ai simplement utilisé la version 3.x." version, mais elle peut être utilisée normalement Très bien, haha.

PostSharp est un plug-in qui peut être installé sur VS. Après l'installation, un élément de menu PostSharp est ajouté à la colonne de menu de VS, comme indiqué ci-dessous.

Si vous devez utiliser la fonctionnalité PostSharp dans un projet général, dans la page d'option [PostSharp] des propriétés du projet, utilisez [Ajouter PostSharp à ce projet] pour ajouter PostSharp au projet.

Après l'ajout, la boîte de dialogue d'invite du plug-in PostSharp apparaîtra, vous invitant à ajouter le package PostSharp correspondant et d'autres contenus, comme indiqué ci-dessous.

Une fois terminé, vous pouvez utiliser les classes liées à PostSharp dans le projet.

2) Ajouter le traitement d'aspect AOP de PostSharp

Il est généralement admis que la dénomination de chaque classe Aspect doit être sous la forme "XXXAttribute ". Parmi eux, « XXX » est le nom de cet aspect. PostSharp fournit une multitude d'"aspects de base" intégrés dont nous pouvons hériter , parmi lesquels nous héritons ici de "OnMethodBoundaryAspect". Cet aspect fournit des méthodes de point de connexion telles que l'entrée et la sortie de fonctions. . De plus, "[Serialised]" doit être défini sur Aspect, ce qui est lié à la gestion interne du cycle de vie d'Aspect par PostSharp.

Le code de la classe Aspect du log est le suivant.

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

Le code de classe pour la gestion des exceptions est le suivant.

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

Le code de la classe Aspect pour le traitement du timing est le suivant.

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

Le code de classe Aspect pour le traitement des transactions est le suivant.

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

Ce qui suit est le code de traitement d'aspect de plusieurs classes d'aspect, comme indiqué ci-dessous.

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

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

De ce qui précède, nous pouvons voir que la gestion conventionnelle des exceptions et le traitement des journaux ont été traités via les attributs, et il ne reste que le code de logique métier spécifique qui est inclus, ce qui améliore grandement la lisibilité du code et est concis et clair.

Exécutez l'appel de fonction de code ci-dessus, nous pouvons voir le contenu spécifique du résultat dans le journal de sortie.

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

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

 

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!