significado programming programacion oriented orientada example aspectos c# .net aop

c# - programming - programacion orientada a aspectos java



Soluciones de Programación Orientada a Aspectos(AOP) para C#(.Net) y sus características (3)

Me gustaría pedir 3 información aquí:

  1. No hay una solución integrada para la Programación Orientada a Aspectos (AOP) en C # (.Net) de Microsoft ¿ es correcto? ¿Hay alguna solución de este tipo en desarrollo o planificada?

  2. ¿Qué soluciones hay que permitan que la Programación Orientada a Aspectos (AOP) se use en C # (.Net)? ¿Cuáles son sus ventajas / desventajas ? No he encontrado ninguna lista exhaustiva que contenga todas las opciones disponibles y cierta información para que yo decida cuál es la que debo usar. Lo más cercano es esta lista .

  3. ¿Cuál es (en su opinión) la mejor solución de AOP para C # (. Net) teniendo en cuenta los siguientes criterios:

    1. podría funcionar de manera similar a AspectJ y tiene una sintaxis similar
    2. simplicidad de uso: no se necesita una configuración XML; solo escriba algunas clases regulares, algunas clases de aspectos y compile para tejer todo junto, luego ejecute.
    3. debe incluir todas las características de AspectJ. Apoyo a los genéricos.
    4. la solución debe ser estable, ampliamente utilizada y mantenida.
    5. debería ofrecer el tejido de binarios (por lo que podría usarse) o el código fuente de C #.
    6. La herramienta GUI para visualizar (o incluso mejor, el complemento a VS) es una ventaja.

Creo que si algo llena la mayoría de los criterios en 3. entonces es un candidato para una solución de uso general. Y no puedo encontrar nada si algunas de las soluciones existentes se ajustan a mis necesidades.

1 - Correcto

2 - PostSharp es una excelente biblioteca AOP para C #

3 - No sé cómo funciona AspectJ, pero con PostSharp simplemente defines tus aspectos como atributos y luego decoras tus métodos con dichos atributos.

Aquí hay un ejemplo de un aspecto que envuelve una llamada a un método con un try catch, y registra las excepciones que se lanzan:

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

Entonces punto por punto

1 - No sé

2 - verificar

3 - No sé 4 - verificar

5 - verificar (bastante seguro)

6 - no - no estoy seguro de cómo usaría una GUI para visualizar aspectos como este

Como señala Adam Rackis, Post # es el camino a seguir, está lo más cerca que podrá llegar a AspectJ en la plataforma .NET.

Las diferencias principales son, obviamente, que AspecJ tiene soporte de lenguaje para aspectos, mientras que Post # es un tejedor de compilación posterior para ensamblados .NET. (por lo tanto, no hay integración de idiomas)

Sin embargo, Post # puede usar puntos de unión, como acceso de campo, try catch blocks, llamadas y funciones (es decir, llamante y destinatario)

  1. No, ni siquiera cerca, AspectJ es un lenguaje, Post # puede usar cortes de puntos personalizados, pero lo más común es usar atributos para decorar los métodos que se van a cortar con puntos (¿eh..grammar?)

  2. comprobar

  3. todo menos el soporte de idiomas

  4. comprobar

  5. comprobar - es un tejedor de compilación de publicaciones

  6. limitado, el tejedor generará información intellisense y mostrará qué métodos se han visto afectados

Si desea un lenguaje .NET que admita aspectos, consulte http://aspectsharpcomp.sourceforge.net/samples.htm

En cuanto a los diferentes enfoques, hay algunos:

  1. Tejido de compilación posterior, esto es lo que hace Post #. Simplemente destruye el ensamblado .NET e inyecta el código de aspecto.

  2. Real Proxy / MarshallByRefObject. Basado en infraestructura remota. Requiere que sus clases hereden de una clase base. Rendimiento extremadamente malo y sin "auto interceptación"

  3. Proxy dinámico. Esto es lo que usaba mi antigua biblioteca NAspect. utiliza una fábrica para crear una subclase del tipo en el que desea aplicar aspectos. La subclase agregará código de mezcla utilizando interfaces y anulará los métodos virtuales e inyectará código de interceptor.

  4. Código fuente de tejido. Como su nombre lo indica, transforma su código fuente antes de la compilación.

[edit] Olvidé agregar este a la lista:

  1. Proxies de interfaz Similar al Proxy dinámico, pero en lugar de aplicar el código de intercepción a una subclase, el código de intercepción se agrega a un proxy de interfaz generado en tiempo de ejecución. Es decir, obtiene un objeto que implementa una interfaz determinada, este objeto luego delega cada llamada a cualquiera de los métodos de la interfaz al código de interceptación AOP y luego delega la llamada al objeto real. Es decir, tiene dos objetos en juego aquí, el proxy y el sujeto (su objeto real).

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

Esto es AFAIK lo que hace Spring.

1) y 3) son los más comunes. Ambos tienen pros y contras:

Post compilación:

Pros:

  • Puede apuntar a cortar casi todo, estático, sellado, privado.
  • Los objetos se pueden crear usando "nuevo"

Contras:

  • No se pueden aplicar aspectos basados ​​en el contexto, es decir, si un tipo se ve afectado, se verá afectado por la aplicación completa.

  • El corte de puntos de constructos privados, estáticos y sellados puede generar confusión, ya que rompe las reglas fundamentales de OO.

Proxy dinámico:

Pros:

  • Contextual, un tipo puede tener diferentes aspectos aplicados según el contexto.

  • Fácil de usar, sin configuración ni pasos de compilación.

Contras:

  • Puntos de corte limitados, solo los miembros de la interfaz y los miembros virtuales pueden ser interceptados

  • debe usar fábrica para crear objetos

El problema es que estás comparando diferentes idiomas e intentando forzar clavijas cuadradas en agujeros redondos.

Para Java AspectJ satisface una necesidad debido a los límites en el idioma, pero .NET no tiene necesariamente estas limitaciones, ya que JVM no lo hace, pero Java sí.

Por ejemplo, puede usar IronPython o IronRuby (además de otros) para escribir ensamblajes que son muy dinámicos, por lo que puede escribir un DSL (lenguaje específico del dominio) que permitirá a un usuario agregar un código que no sea XML, pero que cambiar cómo funciona el programa.

Puede usar los métodos de extensión en C # para cambiar el comportamiento cambiando los ensamblajes, por lo que tiene un ensamblaje que tiene extensiones que se registran en un archivo, luego intercambia ese ensamblaje por otro con el mismo espacio de nombres que enviará los datos a un servicio web , o haz un noop.

Sin embargo, existen limitaciones que pueden ser difíciles de superar, como ser capaz de usar un aspecto para hacer algo en cada función llamada, como usar cflow ( http://www.eclipse.org/aspectj/doc/released/progguide/semantics-pointcuts.html ), pero eso puede deberse a que no he pensado lo suficiente sobre cómo hacerlo.

Mi punto es no dar una explicación completa de cómo .NET no necesita AspectJ, sino mostrar que hay formas de obtener el comportamiento que puede esperar sin usar AOP.

Para las aplicaciones que se ejecutan en la JVM, puede usar Groovy, Clojure, JRuby y Scala, por ejemplo, para evitar las limitaciones de Java.

ACTUALIZAR:

Esperaba mantener mi respuesta más corta, pero cierta comprensión de AOP puede ser útil para agregar contexto a mi respuesta.

La Programación Orientada a Aspectos (AOP, por sus siglas en inglés) es un paradigma de programación diferente para una funcionalidad que abarca varias clases, como el registro. El registro es una situación común, donde es posible que desee registrar todas las consultas SQL que se utilizan, por lo que, en lugar de copiar el código de un lugar a otro, lo coloca en un lugar y se coloca en todos los lugares que especifique. para cambiar donde va el registro, lo cambia en un lugar.

Pero con AspectJ hay más opciones. Por ejemplo, vendes un programa que almacena contraseñas. La empresa A usa IDEA, la compañía B usa AES. Para adaptarse, cambia el código que se usa en el tiempo de ejecución para no tener que arriesgarse a volver a compilar el código e introducir nuevos errores, y se cambia, de modo que cada vez que alguien llama a getPassword() el nuevo código se utiliza para descifrarlo. .

También puede agregar funcionalidad a una clase existente, así que pondría métodos en las interfaces para que todo lo que utilizara esa interfaz ahora tuviera acceso a las funciones, de modo que los métodos ahora fueran concretos, en la interfaz.

Pero, al usar otros lenguajes que están en .NET y JVM, puede hacer todo esto, con la misma modularidad, eligiendo cuidadosamente qué idioma usar. Por ejemplo, en Java puede acceder a clases escritas en Groovy o Scala, por lo que puede obtener más flexibilidad con estos idiomas y aún tener la aplicación principal en Java.

En C # puede usar F #, IronPython o IronRuby, por ejemplo, para obtener esta funcionalidad, o, en algunos casos, puede usar C #.

Por lo tanto, la necesidad de una programación orientada a aspectos se ve disminuida debido a que estos lenguajes funcionales dinámicos o fuertemente tipados están disponibles en estas máquinas virtuales, pero usted cambia la complejidad de trabajar con aspectos por tener una solución multilingüe.

Para obtener más información sobre AOP, IBM tenía algunos artículos increíbles sobre su uso, con su serie AOP @ Work : http://www.ibm.com/developerworks/views/java/libraryview.jsp?search_by=AOP@work:

Para algunas reflexiones sobre AOP en .NET, puede leer AOP de manipulación de código frente a AOP de proxy de tiempo de ejecución, http://rogeralsing.com/2008/01/08/code-mangling-aop-vs-runtime-proxy-aop/