Solutions de programmation orientées vers l'aspect (AOP) pour les solutions de programme (C) (.Net) et leurs caractéristiques

Question

Je voudrais demander pour 3 informations ici:

1. Il n'y a pas de solution intégrée pour la Programmation Orientée Aspects (AOP) en C# (.Net) à partir de Microsoft est-ce exact ? Est-il une telle solution en cours de développement ou prévues ?

2. Quelles solutions qui permettent la Programmation Orientée Aspects (AOP) pour être utilisé en C# (.Net) ? Quels sont-ils des avantages ou des inconvénients ? Je n'ai pas trouver toutes les comprihensive liste qui comprendrait tous avatable options et des informations pour moi de décider qui est le seul à utiliser. Le plus proche est à cette liste.

3. Qu'est-ce que (à votre avis) le meilleur de l'AOP solution pour C#(.Net) considérant suivant les critères:

   1. il devaient travail similaire à AspectJ et a la même syntaxe
   2. simplicité d'utilisation: aucune configuration XML devrait pas être nécessaire - il suffit d'écrire quelques classes régulières, certains aspects de classes et de les compiler de les tisser ensemble, puis sur exécuter.
   3. doit inclure toutes les fonctionnalités d'AspectJ. Soutien pour les génériques.
   4. la solution doit être stable, largement utilisé et mainteined.
   5. devrait offrir de tissage de binaires (donc pourrait être utilisé ) ou du code source C#.
   6. Outil graphique pour la visualisation (ou encore mieux - plugin VS) est un avantage.

Je pense que si quelque chose de fullfils la plupart des critères 3. ensuite, c'est un candidat pour un généralement utilisé de la solution. Et je ne peux pas trouver n'importe où si certaines des solutions existantes s'adapte à mes besoins.

Answer 1

Comme Adam Rackis points, Post# est le chemin à parcourir, il est aussi proche que vous obtiendrez à AspectJ sur le .NET plate-forme.

Principales différences est de toute évidence que AspecJ a la langue de soutien pour les aspects, tandis que le Post# est un post compiler weaver pour .NET assemblées. (donc pas de langue d'intégration)

Cependant, Post# pouvez utiliser adhérer à de tels points d'accès sur le terrain, blocs try catch, les appels et les fonctions (qui est, l'appelant et l'appelé)

1. Non, pas même à proximité, AspectJ est une langue, Post# peut utiliser des pointcuts mais la plus commune est d'utiliser des attributs pour décorer les méthodes à pointcutted(hein..grammaire?)

2. vérifier

3. tout, mais la langue de support

4. vérifier

5. check - c'est un post compiler weaver

6. limitée, le tisserand qui va générer des informations intellisense et de montrer quelles sont les méthodes qui ont été touchés

Si vous voulez une .NET de la langue qui prend en charge les aspects, découvrez http://aspectsharpcomp.sourceforge.net/samples.htm

Concernant les différentes approches, il y a un peu de:

1. Post compiler le tissage , c'est quel Post# ne. Il a simplement mangles l' .NET de l'assemblée et injecte le code de l'aspect.

2. Proxy / MarshallByRefObject. Basé sur l'accès distant de l'infrastructure. Nécessite de vos classes héritent d'une classe de base. Très mauvais rendement et pas de "soi interception"

3. Dynamique Proxy. C'est ce que mon ancienne bibliothèque NAspect utilisé. vous utilisez une usine à créer une sous-classe du type sur lequel vous souhaitez appliquer les aspects. La sous-classe d'ajouter mixin code à l'aide d'interfaces et de redéfinir des méthodes virtuelles et injecter de l'intercepteur de code.

4. Le code Source de tissage. Comme son nom l'indique, il transforme votre code source avant la compilation.

[edit] j'ai oublié d'ajouter à la liste:

1. Interface proxies Similaire à la Dynamique de Proxy, mais au lieu d'appliquer l'interception code pour une sous-classe, l'interception code est ajouté à un moteur d'exécution généré proxy de l'interface. Qui est, vous obtenez un objet qui implémente une interface donnée, cet objet puis de délégués de chaque appel à une des méthodes d'interface, d'abord à l'AOP interception code et puis il délègue l'appel à l'objet réel. Qui est, vous avez deux objets en jeu ici, le proxy et le sujet(votre objet réel).

Client -> Interface Proxy -> AOP interception -> Target/Subject

C'est autant que je sache, ce Printemps n'.

1) et 3) sont les plus courants. Ils ont tous deux des avantages et des inconvénients:

Post Compilation:

Pour:

• Peut de point de coupe à peu près tout, statique , scellé, privé
• Les objets peuvent être créés à l'aide de "nouveau"

Inconvénients:

• Ne peut pas appliquer les aspects basée sur le contexte, qui est , si un type est touché, il sera affecté pour l'ensemble de l'application.

• Pointcutting privé, statique, scellé constructions peuvent prêter à confusion, puisqu'elle brise fondamentaux OO règles.

Dynamique De Proxy:

Pour:

• Contextuelle, un type peut avoir différents aspects appliqués en fonction du contexte.

• Facile à utiliser, pas de configuration ou de créer des étapes.

Inconvénients:

• Limitée pointcuts, interface uniquement les membres et les membres virtuels peuvent être interceptés

• devez utiliser de l'usine pour créer des objets

Answer 2

1 - Corriger

2 - PostSharp est une circulation de l'AOP bibliothèque pour C#

3 - je ne sais pas comment AspectJ fonctionne, mais avec PostSharp il vous suffit de définir vos aspects comme les attributs, puis les décorer vos méthodes avec ces attributs.

Voici un exemple d'un aspect qui encapsule un appel de méthode avec un try catch, et enregistre toutes les exceptions que faire jeter:

[Serializable]
public class ErrorAspectAttribute : OnMethodBoundaryAspect {
    private bool Notify;

    public ErrorAspectAttribute(bool notifyUser = true) {
        this.Notify = notifyUser;
    }

    public override void OnException(MethodExecutionEventArgs args) {
        ErrorLoggerUtil.LogException(args.Exception);           

        if (Notify)
            MessageBox.Show("An error has occurred.  Please save blah blah blah", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);

        args.FlowBehavior = FlowBehavior.Return;
    }
}

Donc, point par point

1 - je ne sais pas

2 - vérifier

3 - je ne sais pas 4 - vérifier

5 - vérifier (sûr)

6 - non - ne sais pas comment vous pourriez utiliser une interface graphique pour la visualisation des aspects comme ceci

Answer 3

Le problème, c'est que vous êtes en comparant les différentes langues et essaie de forcer la place des chevilles dans les trous ronds.

Pour Java AspectJ répond à un besoin en raison des limites de la langue, mais .NET n'est pas nécessairement ces limitations, comme la JVM n'est pas, mais Java n'.

Par exemple, vous pouvez utiliser IronPython ou IronRuby (en plus d'autres) pour écrire des assemblées qui sont très dynamiques, donc vous pouvez écrire un DSL (domain specific language) qui permettront à l'utilisateur d'ajouter dans le code qui n'est pas du XML, mais va changer la façon dont fonctionne le programme.

Vous pouvez utiliser des méthodes d'extension en C# pour changer le comportement par remplacement d'assemblages, de façon à avoir une assemblée qui ont des extensions de fichiers journaux vers un fichier, puis vous remplacez cette assemblée pour une autre ayant le même espace de noms qui va envoyer les données à un service web, ou de faire un noop.

Mais, il y a des limites à ce qui peut être difficile à surmonter, comme le fait d'être en mesure d'utiliser l'un des aspects à faire quelque chose dans chaque fonction appelée, comme l'utilisation de cflow (http://www.eclipse.org/aspectj/doc/released/progguide/semantics-pointcuts.html), mais c'est peut être parce que je n'ai pas assez pensé comment le faire.

Mon but n'est pas de donner une explication complète de la façon dont .NET n'a pas besoin d'AspectJ, mais de montrer qu'il existe des moyens pour obtenir le comportement que l'on peut attendre sans l'aide de l'AOP.

Pour les applications en cours d'exécution sur la machine, vous pouvez utiliser Groovy, Clojure, JRuby et Scala, par exemple, pour contourner les limitations de Java.

Mise à JOUR:

J'espérais garder ma réponse plus court, mais une certaine compréhension de l'AOP peut être utile pour ajouter du contexte à ma réponse.

La Programmation Orientée aspects (AOP) est un paradigme de programmation différent, pour des fonctionnalités qui coupe à travers les classes, telles que l'exploitation forestière. La journalisation est une situation commune, où vous pouvez vous connecter toutes les requêtes SQL utilisées, alors, plutôt que de copier le code d'un endroit à, vous le mettez dans un endroit et il est mis dans partout que vous spécifiez, donc, si vous décidez plus tard de modifier l'endroit où l'enregistrement se passe, vous le changez en un seul endroit.

Mais avec AspectJ il y a plus d'options. Par exemple, vous vendez un programme qui stocke les mots de passe. L'entreprise A utilise IDÉE, la société B utilise AES. Afin de s'adapter vous modifiez le code qui est utilisé lors de l'exécution de sorte que vous n'avez pas à risque de recompiler le code et l'introduction de nouveaux bugs, et il est modifié, de sorte que chaque fois que quelqu'un appelle getPassword() le nouveau code est utilisé pour le décrypter.

Vous pouvez également ajouter des fonctionnalités à une classe existante, de sorte que je mettrais dans les interfaces de sorte que tout de cette interface ont désormais accès à des fonctions, de sorte que les méthodes étaient maintenant de béton, dans l'interface.

Mais, en utilisant d'autres langues qui sont sur le .NET et de JVM vous pouvez faire toutes ces, avec la même modularité, par bien choisir la langue à utiliser. Par exemple, en Java, vous pouvez accéder à des classes écrites en Groovy ou Scala, de sorte que vous pouvez obtenir plus de flexibilité avec ces langues et ont encore la principale application en Java.

En C#, vous pouvez utiliser F#, IronPython ou IronRuby, par exemple, pour obtenir cette fonctionnalité, ou, dans certains cas, vous pouvez utiliser le C#.

De sorte que le besoin pour la programmation orientée aspects est réduit grâce à ces dynamiques, ou fortement typées langages fonctionnels, être disponible, sur ces machines virtuelles, mais, vous le commerce de la complexité de travailler avec les aspects d'une solution multilingue.

Pour en savoir plus sur l'AOP, IBM avait certains des articles incroyables sur l'utilisation, avec leurs AOP@Travail de la série: http://www.ibm.com/developerworks/views/java/libraryview.jsp?search_by=AOP@work:

Pour quelques réflexions sur l'AOP sur .NET, vous pouvez lire le Code d'amputation des AOP vs Proxy à l'Exécution de l'AOP , http://rogeralsing.com/2008/01/08/code-mangling-aop-vs-runtime-proxy-aop/