Aspect Oriented Programming(AOP) with C# and Cross-Cutting Concerns

Aspect oriented programming (AOP) is a concept that ensures increased modularity by separating cross-cutting concerns. Well, what the hell is cross-cutting concerns?

Cross-Cutting Concerns

In short, cross-cutting concerns can be thought as a general expression of the features that should be implemented to a program for reaching better quality and robust execution like caching, monitoring, validation, logging, exception handling. Although these features do not constitute the main logic/purpose of the program, they should be used widely throughout the program for better execution and diagnosis.

Using these features frequently inside main logic code-blocks might be causes high dependency chains and low maintainability. Besides, code readability is reduced, and in large projects with multiple people working on, it may impair the cohesive work of the developers.

To minimize these issues, aspect-oriented programming helps to separate “cross-cutting concerns” from the main logic.

A Quick and Basic Quide to Implement Aspect-Oriented Programming with using PostSharp

Let’s say we are working on an API to perform crud operations on fruits.

Since this is a demo project, we won’t communicate with real database, but rather act on our own custom repository which holds a collection for created objects and performs crud operations on that collection.

We have a Fruit entity which extends EntityBase class. EntityBase class holds common properties for an entity such as Id, CreatedDate, UpdatedDate.

Fruit entity and EntityBase class.

Also, we have a FruitRepository that extends a generic BaseRepository<T> class which also implements a generic IRepository<T> interface.

FruitRepository and BaseRepository

At creation of an instance of an entity, we should set a unique identifier(Id) value for that instance. Also, setting transaction dates at operations like create and update is a good approach to track record lifecycle. What if we want to do these all with aspect-oriented programming? Well, let’s see.

Install PostSharp throught NuGet package manager. Next, let’s create an attribute to be triggered when the referencer method is called.

CommonPropertySetterAttribute.cs

Then, let’s reference our [CommonPropertySetter] attribute on create and update method declerations on our interface.

[CommonPropertySetter] attribute added on Create and Update method signatures.

Since it’s an interface, to distribute the [CommonPropertySetter] attribute to inheriting classes, we use AttributeInheritence with value of Multicast.

Also, we pass an OperationType value to our attribute to determine if current operation is a create or update.

Let’s call our /Fruit endpoint with an example Post request through swagger and see what’s happening.

As we see, when Create method invoked, the aspect described as [CommonPropertySetter] intercepts the method and perform its OnInvoke method to fill required common data to entity as we wanted. With args.Proceed(); the execution context continues to execute original method.

In this short scenario, we have separated the concerns like setting values to common entity properties on create and update operations ​​for our own custom repositories from our main logic. Although it is not the best practice in cases such as manually assigning ids, it is used because it is a good example for aspect.

We could use similar approaches for purposes such as logging, caching, authentication and authorizing requests, notifying users and monitoring to make our software easier to maintain by grouping features and behavior into different manageable contexts which all have a specific purpose and business.