MSDN Magazine - February 2009 - (Page 12)

Figure 2 Adding Employee Class [ActiveRecord] public class Department : ActiveRecordBase { [PrimaryKey] public int DepartmentId { get; set; } [Property] public string Name { get; set; } [HasMany(typeof(Employee))] public IList Employees { get; set; } } [ActiveRecord] public class Employee : ActiveRecordBase { [BelongsTo("DepartmentId")] public Department Department { get; set; } } Figure 3 A PostSharp Aspect for Error Notification public class OnExceptionAttribute : OnExceptionAspect { public string ToAddress { get; set; } public OnExceptionAttribute(string to) { ToAddress = to; } public override void OnException(MethodExecutionEventArgs e) { // TODO: Send ToAddress an e-mail detailing the exception details. // Exception details available in the MethodExecutionEventArgs object } } and updating the Employee class to include a new property (see Figure 2). Notice that the Department class has an Employees property, which returns the set of Employee objects for a specific Department instance. Similarly, the Employee object has a Department property that returns information about the department to which the employee belongs. The ActiveRecord project makes it easy to get started building your application’s architecture on top of a proven framework, NHibernate. Within a few minutes you can craft classes that use the active record pattern without having to master NHibernate’s XML configuration syntax. Price: Free, open-source. castleproject.org/activerecord Aspect-Oriented Programming in the .NET Framework Separation of concerns is a central tenet of software engineering that encourages separating an application’s features and functionality into non-overlapping modules. Each programming paradigm has its own techniques for encouraging this. Procedural programming languages allow 12 msdn magazine developers to encapsulate functionality in subroutines; object-oriented programming languages use classes. Security, logging, and caching are all examples of concerns that typically apply to multiple modules and, when implemented, result in code scattered across those modules to which the rules apply. These types of concerns are said to be cross cutting and are referred to as aspects. Aspect-oriented programming (AOP) is a programming paradigm that focuses on handling the separation of cross-cutting concerns. AOP allows developers to create aspects in a single module and then specify when these run—prior to the execution of a method, when a method completes with success, and so on. For example, with AOP a developer could build an aspect that runs prior to a method’s execution and verifies that the user belongs to a particular role and then specifies to what methods the aspect applies. As a result, whenever one of these specified methods is about to be executed during run time, the corresponding aspect code executes first. AOP is typically implemented through code weaving, which involves injecting the aspect code into the appropriate spots in the application code—either at the end of compile time or during run time. Check out PostSharp (version 1.5), a free, open-source library created by Gael Fraiteur that you can use to implement AOP techniques in the .NET Framework. At its core, PostSharp analyzes and transforms .NET assemblies, allowing for the code weaving necessary to implement AOP. Built atop this core is PostSharp Laos, a lightweight aspect-oriented system that enables developers to create and use aspects in terms of custom attributes. The aspects can then be applied to classes or methods by decorating them with the custom attribute. Alternatively, aspects can be applied to all classes or methods that have a certain naming pattern through syntax in the project’s AssemblyInfo file. Figure 3 shows an example of a PostSharp aspect for error notification. This aspect extends the OnExceptionAspect, which means that the aspect can execute in response to an unhandled exception, perhaps e-mailing an administrator details of the exception. This aspect can be applied to a particular method by decorating it with the OnException attribute, as shown here: [OnException("admin@contoso.com")] private void MyMethod() { // } Immediately after the code has been compiled, PostSharp modifies the IL code of MyMethod, surrounding the existing code with a try catch with a call to the OnException method within the catch block. As a result, the OnException aspect is invoked whenever there is an unhandled exception in MyMethod. You’ll find extensive documentation at the PostSharp Web site, along with a helpful message board. There are also communitycreated plug-ins, libraries, and other tools that use or extend PostSharp. Price: Free, open-source. postsharp.org Scott Mitchell, author of numerous books and founder of 4GuysFromRolla.com, is an MVP who has been working with Microsoft Web technologies since 1998. Scott is an independent consultant, trainer, and writer. Reach him at Mitchell@4guysfromrolla.com or via his blog at ScottOnWriting.NET. Toolbox http://www.castleproject.org/activerecord http://www.postsharp.org http://www.4GuysFromRolla.com http://www.ScottOnWriting.NET

Table of Contents Feed for the Digital Edition of MSDN Magazine - February 2009

MSDN Magazine - February 2009 Contents Toolbox CLR Inside Out Data Points Cutting Edge Patterns In Practice Best Practices .Net Interop "Oslo" Basics Patterns Silverlight Under The Table Foundations Windows With C++ .NET Matters Going Places { End Bracket }

MSDN Magazine - February 2009

For optimal viewing of this digital publication, please enable JavaScript and then refresh the page. If you would like to try to load the digital publication without using Flash Player detection, please click here.