Aspect-oriented programming (AOP) is a programming paradigm that aims to increase modularity by allowing separation of cross-cutting concerns. It does this through aspects, which can encapsulate code that implements a cross-cutting concern and be attached to other code to augment its behavior. There are two main AOP styles - interception, which modifies code execution at runtime through decorators, and IL weaving, which modifies the code during compilation. Both allow aspects to be cleanly separated from core concerns and attached to any code construct.

1. Introduction
to AOP

2. Programming paradigm
which aims to increase modularity
by allowing the separation of
cross-cutting concerns
en.wikipedia.org/wiki/aspect-oriented-programming

3. Programming Paradigm
It is *NOT*
- a programming language
- solution to all your problems
- a first class citizen in Java
or .NET
- a replacement for OOP
It is
- a programming pattern
- a tool in your toolbox
- an easily added language
feature
- complimentary to OOP

4. Modularity
Aspects can…
• Exist in isolated and encapsulated constructs
• Be attached to almost any standard code construct
• Be transported between projects

5. Cross-Cutting Concerns
…aspects of a program that affect other concerns.
These concerns often cannot be cleanly decomposed
from the rest of the system in both the design and
implementation,
and can result in either scattering (code duplication),
tangling (significant dependencies between systems),
or both.
http://en.wikipedia.org/wiki/Cross-cutting_concern

6. …more simply
Any code functionality that repeats itself in a regular
pattern across many unrelated tiers/layers within a
codebase.

8. Cross-Cutting Concerns
View
ViewModel
Model
Services
Domain Model
Repositories
Logging
Security
Auditing
Validation
INotifyPropertyChanged
Undo/Redo
Thread Management
Unit of Work Management
Circuit Breaker

9. AOP Styles
1. Interception
Interjecting the execution of cross-cutting concerns at
run time.
Non-invasive approach to modifying the code execution
path.
2. IL Weaving
Interjecting the planned execution of cross-cutting
concerns during the compilation process.
Invasive approach to modifying the code execution
path.

10. Interception
• Existing in IoC container implementations
• Follows a very strict decorator pattern
• Likely implemented using weak typing
• Run-time operation
• Can be applied en-masse
• Easy to implement if you’re already using IoC

11. Decorator Pattern
//new functionality before
//the code that already exists
//new functionality after
//exception handling

12. Weak Typing

13. En-masse Attachment

14. IL Weaving
• Post compilation process
• Alters the assembly/executable at an IL level
• Scary to people
• Can be attached to almost every code construct
• Very rare that it required changes to existing code
• Run and compile time operations
• Can be much easier to add to legacy code

15. The Process
Write Code
Compile
Application exe/dll
AOP post
compiler/weaver
Throw
compile-time
error
Deploy exe/dll

16. Constructs
• Methods (private/public/internal/etc)
• Properties
• Field level variables
• Events
• Event registration/de-registration
• Code generation

17. Run Time vs Compile Time
Run Time
• All aspect code executes in application context
Compile Time
• Code can be designated to run during post-compilation
• Compilation can fail for correct syntaxes but incorrect
business logic

18. Tooling
• Interception
• Castle Winsdor
• StructureMap
• Ninject (with Ninject.Extensions)
• AutoFac (with Autofac.Extras)
• IL Weaving
• PostSharp (current)
• LinFu

19. The Traditional Arguments Against AOP
• It is “magic”
• We won’t be able to debug properly
• How do we know where aspects will be executed?
• It’s another thing we have to learn
• Changing the aspect will break the entire application

20. “Its magic!” & “We can’t debug it!”
• Both interception and IL weaving provide full line-by-line
debugging
• Attachment of aspects is explicit as you want it to be

21. “But which aspect(s) will run?”
• This is a tooling/discoverability problem, not a problem with
AOP itself
• PostSharp has very good VS integration showing what aspects
are attached to a piece of code
• Interceptor discoverability is a bigger problem

22. “Its another thing we have to learn”
Is it worse if we train them and
they leave or if we don’t train
them and they stay?

23. “Changing the aspect can break the
entire application!”
• You can probably do that in an number of different ways with
any codebase that doesn’t use AOP
• This is a problem caused by tight coupling and poor separation
of concerns

24. Your Project is Already Established…
You use IoC
• For logging, caching and possibly transaction management use
interception
• If the cross cutting concerns are more complex (Undo/Redo,
thread management) use IL Weaving
You don’t use IoC
• The only real option is to use IL Weaving

25. You’re Starting a New Project…
You have AOP buy-in from senior developers
• Start with IL Weaving, but start with simple, pre-built aspects
• Write custom aspects as experience and need grows
AOP is still unknown to the senior people on the team
• Start with IL Weaving, but start in a very isolated manner
• Use this as a proof of concept until you have senior level buy-in

26. gracias
Donald Belcham
@dbelcham
donald.belcham@igloocoder.com