Quel est l'aspect de la programmation orientée?

AOP aborde le problème de la transversales préoccupations, ce qui serait tout type de code est répété dans de méthodes différentes et ne peuvent en général pas être complètement remaniée dans son propre module, comme avec l'exploitation forestière ou de la vérification. Ainsi, avec AOP, vous pouvez laisser ce genre de choses hors de la main de code et de le définir à la verticale comme suit:

function mainProgram()
{ 
   var x =  foo();
   doSomethingWith(x);
   return x;
}

aspect logging
{ 
    before (mainProgram is called):
    { 
       log.Write("entering mainProgram");
    }

    after (mainProgram is called):
    { 
       log.Write(  "exiting mainProgram with return value of "
                  + mainProgram.returnValue);
    }
 } 

aspect verification
{ 
    before (doSomethingWith is called):
    { 
       if (doSomethingWith.arguments[0] == null) 
       { 
          throw NullArgumentException();
       }

       if (!doSomethingWith.caller.isAuthenticated)
       { 
          throw Securityexception();
       }
    }
 }

Et puis un aspect weaver est utilisé pour compiler le code en ceci:

function mainProgram()
{ 
   log.Write("entering mainProgram");

   var x = foo();   

   if (x == null) throw NullArgumentException();
   if (!mainProgramIsAuthenticated()) throw Securityexception();
   doSomethingWith(x);   

   log.Write("exiting mainProgram with return value of "+ x);
   return x;
} 

Copié à partir d'un duplicata pour l'exhaustivité (Einstein):

Les exemples classiques sont la sécurité et la journalisation. Au lieu d'écrire du code dans votre application pour se connecter occurrence de x ou de vérifier l'objet z pour la sécurité de contrôle d'accès il y a un langage engin "hors bande" de code qui peut systématiquement injecter de la sécurité ou de l'exploitation forestière dans les routines qui ne sont pas nativly les avoir dans une telle façon que même si le code ne nécessite pas d'alimentation, sa prise en charge.

Un exemple plus concret est le système d'exploitation en fournissant les contrôles d'accès à un fichier. Un logiciel n'a pas besoin de vérifier les restrictions d'accès parce que le système sous-jacent ne fait que travailler pour elle.

Si vous pensez que vous avez besoin de l'AOP dans mon expérience, vous avez vraiment besoin d'investir plus de temps et d'efforts appropriés de gestion des meta-données au sein de votre système, avec un accent mis sur le bien pensée structurelle /conception de systèmes.

Copié à partir d'un duplicata pour l'exhaustivité (Buzzer):

De la classe et de la méthode attributs .NET sont une forme de programmation orientée aspects. Vous décorer vos classes/méthodes avec des attributs. Derrière les coulisses de cette ajoute le code de votre classe/méthode qui effectue les fonctions particulières de l'attribut. Par exemple, le marquage d'une classe sérialisable lui permet d'être sérialisé automatiquement pour le stockage ou la transmission à un autre système. D'autres attributs peuvent marquer certaines propriétés non sérialisable et celles-ci seraient automatiquement omis de l'objet sérialisé. La sérialisation est un aspect, mis en œuvre par un autre code dans le système, et appliquer à votre classe de l'application d'une "configuration" de l'attribut (décoration) .

AOP peut être utilisé pour effectuer des actions qui ne sont pas liées à la logique métier de votre application, comme l'exploitation forestière, la mise en cache, etc. Ces actions peuvent être mis dans une partie distincte de votre application, puis réutilisé tout au long de l'application. Il y a généralement deux façons d'y parvenir. L'injection de code automatiquement par un préprocesseur avant/après d'une méthode, ou d'attacher des classes proxy d'interception d'un appel de méthode et pouvez alors exécuter des choses avant/après un appel de méthode.

Ici est un exemple .Net. Il utilise des classes proxy pour intercepter les appels de méthode
et d'exécuter du code avant ou après saif appels de méthode.

La Programmation Orientée aspects (AOP) dans .NET de Base et C# à l'aide de AutoFac et DynamicProxy