Every time I here a podcast or read a blog entry about it, even here, they make it sound like string theory or something. Is the best way to describe it OOP with dependency injection on steroids?
Every time someone tries to explain it, it’s like, aspects, [Adults from Peanuts Cartoon sound], orthogonal, [more noise], cross-cutting concerns, etc. Seriously, how could it be described in layman’s terms?
Layman's terms, so let me give you an example. Let's say you have a web application, and you need to add error logging / auditing. One implementation would be to go into every public method and add your try catch blocks, etc...
Well, aspect-oriented says hogwash with that. Let me inject my method around your method so, for example, instead of calling YourClass.UpdateModel(), the system might call,
LoggingHandler.CallMethod(). This method might then redirect the call to UpdateModel, but it wraps it in a try-catch block to handle logging errors.
Now the trick is that this redirection happens automagically, through configuration or by applying attributes to methods.
This works for, as you said, cross cutting things which are very common programing elements that exist in every domain, such as: Logging, auditing, transaction management, and authorization.
The idea behind it is to remove all this common plumbing code out of your business / application tier, so you can focus on solving the problem, not worrying about logging this method call or that method call.