1. Taming Brownfield
Codebases with AOP

2. The typical Brownfield codebase
• Spaghetti code
• Tightly coupled
• Lack of organization
• Inconsistent
• Dangerous to change

3. Brownfield reclamation
• Introduce consistency
• Require minimal effort
• Introduce limited risk

4. How AOP can help
• Introduce consistency
• Aspects are isolated and centralized features
• Require minimal effort
• Make use of pre-existing aspects
• Introduce limited risk
• Granularity choices
• AOP is reversible

5. AOP choices
• Interceptors
• Depends on Inversion of Control Containers
• Requires Dependency Inversion/Injection patterns in the code
• Existing frameworks
• Many have injection points
• Isolated functionality added at these points is AOP
• IL Weaving
• Modifies the code post compilation
• Limited codebase changes

6. IL Weaving
• Each aspect is an implementation
• Granular attachment options
• Changes are usually additive

7. Implementation
[NotifyPropertyChanged]
public class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string FullName
{
get { return this.FirstName + " " + this.LastName; }
}
}

8. Implied Functionality
public class Person : INotifyPropertyChanged
{
private string firstName;
private string lastName;
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged(string propertyName)
{
if ( this.PropertyChanged != null )
{
this.PropertyChanged( this,
new PropertyChangedEventArgs(propertyName) );
}
}
public string FirstName
{
get { return this.firstName; }
set
{
if ( this.firstName != value )
{
this.firstName = value;
this.OnPropertyChanged("FirstName");
this.OnPropertyChanged("FullName");
}
}
}
public string LastName
{
get { return this.lastName; }
set
{
if ( this.lastName != value )
{
this.lastName = value;
this.OnPropertyChanged("LastName");
this.OnPropertyChanged("FullName");
}
}
}
public string FullName
{
get { return this.FirstName + " " + this.LastName; }
}

9. Implementation
public class OrderFulfillmentService
{
[HandleException]
public void Fulfill( Order order )
{
// Do stuff.
}
}

10. Implied Functionality
public class OrderFulfillmentService
{
public void Fulfill( Order order )
{
try
{
// Do stuff.
}
catch ( Exception e )
{
if ( ExceptionHandler.Handle(e) )
throw;
}
}
}

11. Implementation
[assembly:
Log(AttributeTargetTypes="Contoso.Crm.Orders.*",
AttributeTargetMemberAttributes = MulticastAttributes.Public)]
public class OrderFulfillmentService
{
public bool IsValid( Order order )
{
if ( order.Lines.Count == 0 )
return false;
if ( order.Amount < 0 )
return false;
return true;
}
}

12. Existing implementations
• Toolkits exist for many common needs
• Logging
• INotifyPropertyChanged
• Exception handling
• Some will be difficult to use in brownfield scenarios

13. Moving forward with AOP and Brownfield
• IL weaving is the
• Easiest technique to add non-functional requirements
• Lowest impact to existing code
• Easiest to back out
• Make use of existing aspects
• Don’t forget to leverage frameworks already used

14. Donald Belcham
@dbelcham
donald.belcham@igloocoder.com