Cross Cutting Concerns
are global concerns that span across methods, classes, applications—and can be
concerns widely affecting a whole company or industry. Think of patient records or a financial
history, and things always needed in those industries and how it affects each
method of code! There are all kinds of required security for each step and any
errors need to be carefully logged. In
other words, integral parts of an application that have to be performed across
the layers. Examples are Logging, Exception/Error
Handling, Data Validation, Business Rules, Caching, Security, Communication,
and others.
Aspect Oriented Programming
(AOP) = program it once in its own section, and apply it as needed
throughout the application. You should
only add something to this section if it is to be reused often. If it is only a couple of times, try to
implement it directly in your code to cut down on abstracting away too
much. On the good, and bad, side.. anything
implemented here with a bug is easily fixed in one place, but can wreck havoc
globally.
Java supports AOP, whereas C# only partially supports it (hence
PostSharp and other 3rd party extensions). An application with strong architecture tends
to have separate layers so different concerns don’t interact more than necessary,
which is better for maintainability and for changes over time. AOP separates general code form code that is
globally reusable code present throughout the layers; this is addressing the
crosscutting concern.
So now our code, for example could be separated into:
- · Presentation layer
- · Domain logic layer
- · Data storage layer
- · General globally needed stuff layer (like Exceptions and Logging!)
You can standardize exception handling using AOP and reduce
the amount of code written for exception handling. Most commonly in .NET, you will see
post-processing (PostSharp) and code interception (dependency injection). As a
sample for how to use AoP to address the cross cutting aspect of Error handling,
we will talk about PostSharp.
Using PostSharp for post-processing, you can handle all of
the exceptions in one system though a single function. Using PostSharp, you add
an attribute [ExceptionAspect] to a method and PostSharp will wrap the method
in a try/catch block for you. This cuts
down on code added and allows you to reuse the same try/catch logic over and
over again easily. You can customize
your exception handling logic with PostSharp
Please see here for detailed instructions on how to download and
implement PostSharp: https://michaelllucas.wordpress.com/2014/11/05/exception-handling-using-postsharp-c/
Sample scenario: You have a win forms project with an in-memory
data store. You search for a name that isn’t
in the list and get an error that is cryptic and shows too much sensitive
info.
Below is a normal try/catch:
Below is a custom exception wrapper using PostSharp (this is
our Aspect class):
You can handle the issue in the data layer by creating the Database Exception Wrapper and
customizing the logic for showing a useful and non-sensitive message.
Below is a try catch using PostSharp:
Notice the attribute at the top using the [DatabaseExceptionWrapper], now the entire
function that was wrapped before is considered wrapped in the custom try catch
wrapper just made.
“The way OnExceptionAspect works is by wrapping the method
in a try/catch block and catching exceptions of type Exception. But there will
be cases when you want to handle a specific type of error.” You can specify in
the aspect class (in our case the DatabaseExceptionWrapper class) what type of
error you want to catch so you aren’t catching all general errors.
Below it
specifies to only catch the InvalidOperationException.
*Note screenshots and
sample are from: http://www.postsharp.net/blog/post/Day-1-e28093-OnExceptionAspect
(I just distilled it down to summarize it here).
Potential cons of PostSharp: Increased build times. May need to exclude from
local build. Most say advantages
outweigh increased build time (http://stackoverflow.com/questions/417163/anyone-with-postsharp-experience-in-production).
References:
Extra reading:
