wwe software significado programming programacion paradigma oriented orientado orientada ejemplos desarrollo caracteristicas aspectos aop

aop - software - programacion orientada a aspectos c#



Ejemplos de programación orientada a aspectos (14)

¿Alguien puede publicar un ejemplo de programación orientada a aspectos (AOP) que no está registrando?

Miré varios recursos, pero todos los ejemplos son registros triviales. Para que sirve?

Comprobación de invariante público. Dado que PostSharp 1.5 vendrá con herencia de aspecto, incluso a través de interfaces, dará muchas nuevas oportunidades.

No puedes tener herencia múltiple en Java. Sin embargo, al usar AOP puede tener herencia múltiple "limitada". Intenta googlear esto para ver algunos ejemplos.

También estoy de acuerdo con Eyvid. El artículo de Hannemann y Kiczales es excelente para aprender los conceptos básicos sobre los patrones de diseño y obtener algunos excelentes ejemplos de AOP.

Otro ejemplo clásico (como el registro) es el almacenamiento en caché. Pero otros ejemplos son más interesantes.

Seguridad: verificar que los usuarios tengan los permisos adecuados antes de ejecutar ciertos métodos.

Validación:

[NotNull] public string Property1 { get; set; } [Length(Min = 10, Max = 20)] public string Property2 { get; set; } [Regex(Expression = @"[abc]{2}")] public string Property3 { get; set; }

Mi álbum de fotos usa aspectj por tres cosas:

  1. Implementar el "patrón" de observador como una pieza de código reutilizable.
  2. Destruir una sesión para un tipo específico de llamada.
  3. Establecer banderas sucias en los DTO cuando ocurre la mutación.

El primero, en particular, salió directamente de una charla técnica de Google sobre AOP . Se trata de la modularidad de una manera diferente a la que la mayoría de la gente considera. Definitivamente, recomiendo mirar eso si está interesado en cómo usarlo para siempre.

Deshacer: estoy llamando a un ensamblado de un tercero que admite operaciones de deshacer. Requiere que las personas que llaman creen un contexto de deshacer, invoquen algunos métodos en el ensamblado, y luego destruyan el contexto de deshacer. Los contextos se pueden anidar. Además, si se crea un contexto pero se deja en un estado no deseado que requiere un reinicio de la aplicación.

Normalmente para usar deshacer escribiría algo como esto

void foo() { int id = lib.create_undo_context(); try { lib.performsomeaction(); lib.performsomeaction(); lib.performsomeaction(); } finally { lib.destroy_undo_context(id); } }

con PostSharp defino un atributo llamado [Deshacer] que crea el contexto de deshacer cuando el método se inicia y lo destruye cuando el método sale (incluso si se lanza una excepción), por lo que el código se ve así.

[Undo] void foo() { lib.performsomeaction(); lib.performsomeaction(); lib.performsomeaction(); }

Es un poco más complicado implementar esto de lo que estoy demostrando porque me he asegurado de que todos los contextos de deshacer se limpien incluso en los casos en que hay contextos de Deshacer anidados, pero se entiende la idea.

Gestión de transacciones.

En mi opinión, no desea que los objetos que pueden ser parte de una transacción sean conscientes de que están en una transacción. Con AOP, puede componer objetos en transacciones según sea necesario sin que los objetos de la transacción tengan que conocer el hecho de que están en una transacción o incluso de la existencia del marco AOP.

He usado programación orientada a aspectos para implementar un motor de búsqueda de palabras clave. Fue más como un experimento, pero muestra cómo AOP se puede utilizar para otros fines que no sean el registro y el seguimiento.

Básicamente:
(i) El usuario del motor marca sus clases como KeywordSearchable,
(ii) El motor comienza a rastrear la creación y destrucción de estas instancias de KeywordSearchable,
(iii) El motor extrae las palabras clave de estos objetos KeywordSearchable,
(iv) Dados los objetos y las palabras clave, el algoritmo se ocupa de la búsqueda.

Se pueden encontrar más detalles al respecto en http://montrealistic.blogspot.com/2011/08/aspect-orientted-implementation-of.html .

Inyección de dependencia

Estrictamente hablando, la inyección de dependencia no es más que una preocupación transversal. Muchos frameworks de inyección de dependencia usan un estilo de programación basado en atributos como este:

public class Car:IDisposable { [Inject] public IGearBox Gearbox { get; set; } ... }

El atributo [Inyectar] también podría diseñarse como un aspecto sin ninguna dependencia a un marco externo.

Uno de los ejemplos que se prestó directamente de esta Programación Orientada a Aspectos: Investigación Radical en Modularidad, el video de Youtube estaba pintando en una pantalla. En el ejemplo, tiene un programa de dibujo, que consiste en puntos, formas, etc. y cuando se producen cambios en esos objetos, debe indicarle a la pantalla que se actualice. Sin manejarlo en un aspecto, terminas repitiéndote un poco.

AOP, como lo he entendido, fue creado para no repetirse por cuestiones transversales que podrían no tener nada que ver con la lógica empresarial. Con los aspectos, puedes modularizar estas preocupaciones a los aspectos. Uno de los ejemplos fue el inicio de sesión, pero hay muchas cosas diferentes que podría terminar repitiendo. Ha estado evolucionando desde entonces y ya no se trata de programación orientada a aspectos, sino que también tiene modelos orientados a aspectos.

Se puede encontrar más información acerca de la programación orientada a aspectos a partir de estas fuentes:

Ejemplos de AOP:

  • Un analizador y evaluador de expresiones aritméticas. Esto podría haber sido programado usando el patrón de visitante, pero creo que los aspectos son una mejor alternativa.
  • Un editor de texto simple, en el cual algunas tareas de administración (por ejemplo, mantener el indicador "archivo ha cambiado" y el título de la ventana) se tratan como aspectos separados.
  • Una estructura de datos para cadenas de caracteres, en la que las cadenas se representan como árboles para que la selección de concatenación y subcadena se pueda implementar sin copiar. Para mantener la eficiencia, los árboles a veces necesitan ser reequilibrados; el código de equilibrio se trata como un aspecto.

Imaginemos que desea registrar un mensaje dentro de los métodos de su modelo de dominio:

Ejemplo: Registro sin AOP:

namespace Examples/Forum/Domain/Model; class Forum { /** * @Flow/Inject * @var /Examples/Forum/Logger/ApplicationLoggerInterface */ protected $applicationLogger; /** * Delete a forum post and log operation * * @param /Examples/Forum/Domain/Model/Post $post * @return void */ public function deletePost(Post $post) { $this->applicationLogger->log(''Removing post '' . $post->getTitle(), LOG_INFO); $this->posts->remove($post); } }

Si tiene que hacer esto en muchos lugares, el registro se convertiría en parte de su lógica de modelo de dominio. Tendría que inyectar todas las dependencias de registro en sus modelos. Dado que el registro no es nada de lo que un modelo de dominio debería preocuparse, este es un ejemplo de un requisito no funcional y una llamada preocupación transversal.

Con AOP, el código dentro de su modelo no sabría nada sobre el registro. Simplemente se concentrará en la lógica de negocios.

Seguridad

  • Inyectar código que verifica los permisos y bloquea el acceso

Mensajes de error más amistosos para asp.net webcontrols / webparts

Actuación

  • Inyectar código que establece los contadores de rendimiento para obtener una visión general de dónde está la aplicación lenta