David Hayden [MVP C#]

Decorator Pattern

David Hayden — Tue, 30 Sep 2008 14:39:00 GMT

The other day I created a screencast that showed off the Unity Interception Extension and RemotingPolicyInjector to show AOP development in .NET applications:

Unity Interception Extension and RemotingPolicyInjector Screencast - Unity Tutorials

and then followed that up with a post using PostSharp 1.0 that showed the same functionality without using the Unity Interception Extension:

PostSharp AOP and Unity IoC Container - Alternative to Interception Extension and RemotingPolicyInjector

Decorator Pattern

Continuing with this idea of showing alternatives using the same example, I thought it might be interesting to show the Decorator Pattern which can be used when the Policy Injection Application Block and PostSharp may be overkill for your application.

In the two examples mentioned above I created a Stopwatch Attribute that timed the ILogger.Write Method used in our console application:

public interface ILogger
{
    void Write(string message);
}
 
public class ConsoleLogger : ILogger
{
    public void Write(string message)
    {
        Console.WriteLine();
        Console.WriteLine("*** In Logger ***");
        Console.WriteLine(string.Format
            ("message : {0}", message));
    }
}

Creating these attributes is pretty simple for use in the Policy Injection Application Block and PostSharp. However, we can avoid the use of these 3rd party libraries by creating a StopwatchLoggerDecorator Class that will achieve the same results:

public class StopwatchLoggerDecorator : ILogger
{
    private readonly ILogger _inner;
 
    public StopwatchLoggerDecorator(ILogger inner)
    {
        _inner = inner;
    }
 
    public void Write(string message)
    {
        Stopwatch sw = new Stopwatch();
        sw.Start();
 
        _inner.Write(message);
 
        sw.Stop();
 
        Console.WriteLine();
        Console.WriteLine(string.Format("Time Elapsed: {0} ms", sw.ElapsedMilliseconds));
    }
}

The Decorator Class implements the same ILogger Interface and takes the "real" ILogger in its constructor, ConsoleLogger. Inevitably it passes the Write Call onto the real logger, but before doing so starts a Stopwatch. After the call to ConsoleLogger is finished ( _inner.Write ), it stops the Stopwatch and displays the elapsed time in the console.

In keeping with the examples mentioned above, one can register the ILogger in your IoC Container / Dependency Injection Tool of choice. Here is an example using Unity:

IUnityContainer container = new UnityContainer();
 
// Register Logger
ILogger consoleLogger = new ConsoleLogger();
 
ILogger logger = new StopwatchLoggerDecorator(consoleLogger);
 
container.RegisterInstance<ILogger>(logger,
    new ContainerControlledLifetimeManager());
 
// Use Logger
var registeredLogger = container.Resolve<ILogger>();
 
registeredLogger.Write("Hello!");
 
Console.ReadLine();

The results are as follows:

Although a simple example, you can use this with all sorts or cross-cutting concerns or anytime you want to decorate existing classes without modifying them. Note how easy it is to remove the functionality without modifying any of the classes. You simply just change the configuration code to no longer use the decorator.

IUnityContainer container = new UnityContainer();
 
// Register Logger
container.RegisterType<ILogger, ConsoleLogger>(new ContainerControlledLifetimeManager());
 
// Use Logger
var registeredLogger = container.Resolve<ILogger>();
 
registeredLogger.Write("Hello!");
 
Console.ReadLine();

Although not an example of the Open-Closed Principle ( OCP ) per se, the Decorator Pattern supports the idea that we don't want to change the ConsoleLogger to add new behavior and possibly introduce bugs, but instead decorate it with another class that can offer that additional behavior. This also touches upon the Single-Responsibility Principle ( SRP ) in that the Console Logger keeps to its single responsibility of logging to the Console as opposed to adding "profiling" responsibilities to it.

Decorator Pattern at Runtime

Often you use the Decorator Pattern when it is decided at runtime whether or not you want to add the additional functionality offered by a Decorator Class.

Let's re-write the code above to encapsulate the registration of our Infrastructure Services and introduce a debug setting that decides at runtime whether or not we wish to decorate the ConsoleLogger with the StopwatchDecoratorLogger Class:

public class InfrastructureExtension : UnityContainerExtension
{
    private readonly bool _debug;
 
    public InfrastructureExtension(bool debug)
    {
        _debug = debug;
    }
 
    protected override void Initialize()
    {
        ILogger logger;
 
        if (_debug)
            logger = new StopwatchLoggerDecorator(new ConsoleLogger());
        else
            logger = new ConsoleLogger();
 
        Container.RegisterInstance<ILogger>(logger, new ContainerControlledLifetimeManager());
    }
}

and now we set-up the Unity Container as follows:

IUnityContainer container = new UnityContainer();
container.AddExtension(new InfrastructureExtension(false));
 
// Use Logger
var registeredLogger = container.Resolve<ILogger>();
 
registeredLogger.Write("Hello!");
 
Console.ReadLine();

We can easily get the value of debug from a configuration setting, but in this case we just pass it in directly in the code above:

container.AddExtension(new InfrastructureExtension(false));

This will allow us to decide at runtime whether or not to decorate the ConsoleLogger with the StopwatchLoggerDecorator

Conclusion

If you prefer not to use the 3rd party AOP style libraries, you can always get back to the basics and use the Decorator Pattern. Note that at some point the 3rd party libraries, like Policy Injection Application Block and PostSharp, may begin to offer you much more gains in developer productivity and application maintenance if you find yourself creating a lot of decorators.

Hope this helps,

David Hayden

Related Posts:

Unity v1.2 Screencast - Interception Extension for AOP Style Development

David Hayden — Mon, 22 Sep 2008 15:48:00 GMT

I mentioned the Enterprise Library 4.1 and Unity 1.2 Project Kickoff as well as how the first drop of Unity 1.2 has some things for Silverlight, a CLR bug fix, and support for Generic Decorator Chains.

But probably one of the cooler parts of Unity 1.2, which is still in the early drops, is the migration of the Enterprise Library Policy Injection Application Block ( PIAB ) core features to a new Unity.Interception Assembly. In the assembly is a new Unity Interception Extension and RemotingPolicyInjector that give you AOP Functionality built into the IoC Container itself. Of course, if you have been using Windsor, Spring, and other Dependency Injection Tools this will be old hat. It is just nice to see Unity beefing up its support so that when you want or need to use Unity you can use the very familiar PIAB functionality baked into it.

To show one way to use the new functionality, which is subject to change, I created a screencast:

Unity Interception Extension and RemotingPolicyInjector Screencast

This style of development is great for lifting cross-cuttings concerns out of your code as I mentioned when using the Policy Injection Application Block for helping with validation in ASP.NET MVC:

I hope the screencast is useful.

T4 Templates for Code Generation Screencast

David Hayden — Tue, 22 Jul 2008 19:55:00 GMT

I put together a quick screencast showing how to leverage T4 Templates in Visual Studio 2008 for Code Generation:

T4 Templates in Visual Studio for Code Generation Screencast

I show step-by-step how to create a simple T4 Template and then how to generate various Entity, Data Access Object, and Factory Classes using more advanced T4 Templates that one might use to create a simple custom data access layer. I have seen other screencasts that have used SQL Server Management Objects, but in my case I use database schema related functionality in good 'ol ADO.NET. Although I wouldn't use this technique to build a data access layer given all the cool code generators and O/R Mappers, it is a pretty decent way to show the possibilities with T4 Templates.

I picked up a new iPhone 3G the other day and absolutely love it, so I also created a version of the screencast that you can download and play on the iPhone. In fact, several of the more recent Unity and Enterprise Library 4.0 Screencasts now have an iPhone version.

If you are interested in some of the ADO.NET techniques I used in the screencast to get database schema information, check out the show notes with links to various tutorials.

I hope the screencast is useful.

Unity IoC and ASP.NET Part II Screencast with Appearances by Autofac and Ninject

David Hayden — Tue, 01 Jul 2008 19:12:00 GMT

I created a final screencast focusing on Unity, called-

Unity and ASP.NET Web Pages Dependency Injection Part II with Special Guests - Autofac and Ninject

As promised in the previous screencast:

Unity IoC and ASP.NET Screencast - Dependency Injection into Web Pages

I wanted to show at least one other way to accomplish dependency injection with Unity in ASP.NET Webforms Web Pages without requiring base classes for pages, masterpages, usercontrols, etc. This example highlights the use of a custom HttpModule and subscribing to the PreRequestHandlerExecute Event. This is a very common method that I mentioned being used in the older Web Client Software Factory v1.0 and 1.1 as well as currently in Autofac via the DependencyInjectionModule in Autofac.Integration.Web. I am sure it is being used numerous other places as well.

During the screencast I discuss two other dependency injection tools, Autofac and Ninject, which are wonderful IoC Containers that are open-source, lightweight, and easy-to-use as well as offer some wonderful integrations with Webforms, ASP.NET MVC Framework, Winforms, WCF, and various other 3rd party open-source libraries like Castle DynamicProxy2, Log4Net, etc.

During the screencast I show a custom HttpModule, NinjectHttpModule, that I created and added to my copy of Ninject.Framework.Web to offer this same functionality with Ninject. Using inspiration from both Autofac and Ninject, I then show a Unity.Integrations.Web Assembly that uses techniques from both Autofac and Ninject to provide this functionality with Unity.

In addition to Unity, I highly recommend you check out Autofac and Ninject. Download the source code and binaries, check out the examples on the wiki's, and get involved in the discussion groups:

You can find links to samples I have created using Autofac and Ninject in the screencast show notes.

Hope you enjoy the screencast.

C# 3.0 Language Features and LINQ Heroes Happen Here Presentation

David Hayden — Sun, 22 Jun 2008 15:29:00 GMT

Yesterday we had our Heroes Happen Here Launch Event in Sarasota, Florida. I presented the new language features in C# 3.0 as well as LINQ. It was rather cool to give this presentation, because a couple weeks earlier I was answering questions and showing demos on these same topics in The Learning Center at TechEd 2008 in Orlando.

There was a lot of material to cover in an hour, but we got through it all with good participation:

Object and Collection Initializers
Automatically Implemented Properties
Partial Methods
Implicitly Typed Local Variables
Anonymous Types
Extension Methods
Lambda Expressions and Closures
Query Expressions

For LINQ I showed several demos solving the same challenge using the various flavors of LINQ:

LINQ To Objects
LINQ To XML
LINQ To SQL
LINQ To DataSets
LINQ To Entities
ASP.NET Dynamic Data using LINQ To SQL

For those looking for resources on C# 3.0, I would first check out the C# Language Section on MSDN, which has links to the language specification, downloadable samples, keywords, etc. If you don't have Visual Studio, you can download the Visual C# 2008 Express Edition for free.

For LINQ samples, check out the 101 LINQ Examples on MSDN.

If you are interested in books, I reviewed 4 that I really enjoyed and highly recommend on C# and LINQ:

If you are looking for bite-sized examples on C# 3.0, I put together a series of C# 3.0 Language Samples when I was learning the new C# 3.0 Language Features myself:

I created some LINQ To SQL Tutorials as well. As I mentioned at the presentation, check out Ian Cooper's LINQ To SQL Series. Matt Warren has a great series of articles on building an IQueryable Provider for insight on how LINQ to SQL works.

Thanks to everyone who attended the Heroes Happen Here Event in Sarasota.

Unity and ASP.NET Screencast

David Hayden — Tue, 17 Jun 2008 18:30:00 GMT

I am still catching up after a week at TechEd and getting used to the fact that the kids are off from School for the summer. Ahhhhh... the joys and challenges of a stay-at-home Dad :)

This past weekend I downloaded Screenflow, which is a screencast application for the Mac. My goal was to create a new Unity and ASP.NET Screencast using Screenflow, but I need to spend a bit more time with Screenflow before I go into "production" with it. It is different enough from Camtasia, which I love, such that I need to iron out the use of Visual Studio 2008 in VMware Fusion, Apple Keynotes, the iSight Camera on the MacBook Pro, and the fact that I prefer to do the screencast using my external monitor and headset. Another week and I think I will have it all figured out.

In the meantime, I went ahead and created the screencast in Camtasia, which is a phenomenal screencast application for the PC. Therefore, if you are interested in seeing one way to get Unity IoC to work in ASP.NET Webforms for dependency injection into your pages, check out the following screencast:

Unity IoC and ASP.NET Screencast - Dependency Injection into Web Pages

You can also download the code presented in the screencast.

The screencast uses a similar technique to what you will find in the Web Client Software Factory, where you can derive your web pages from a base page class and then call UnityContainer.BuildUp on the page to do property injection into the page. Of course, the WCSF does not use Unity, but the techniques are similar. Although I don't show it, you can use a similar technique for your MasterPages and UserControls.

Hopefully you find the screencast useful.

On a side-note, you might want to check out Ninject 1.0 - Lightning fast dependency injection for .NET, which I noticed was released in 1.0. You gotta love the contributions by the developer community.

Logging Application Block and Unity Screencast - EntLib 4.0

David Hayden — Mon, 02 Jun 2008 03:48:00 GMT

I created another screencast over the weekend showing how you can integrate Unity with Enterprise Library 4.0:

Enterprise Library 4.0 Logging Application Block and Unity IoC Screencast

This screencast discusses the Logging Application Block with Unity. The Logging Application Block comes with a LoggingBlockExtension that adds the various configuration information into Unity so you can inject a LogWriter Class into your custom business classes. This is very similar to how the Data Access Application Block works with Unity as I showed in a previous screencast:

Enterprise Library 4.0 Data Access Application Block ( DAAB ) and Unity IoC Screencast

The screencast walks through a Model-View-Presenter type scenario where you have an AddCustomerPresenter Class with a dependency on an ICustomerDataSource that has a dependency on the LogWriter Class in the Logging Application Block. The screencast shows how to create the UnityContainer, add the appropriate Enterprise Library Unity Extensions, add additional type mappings, etc. The example uses a simple Rolling Flat File TraceListener and shows you the new Midnight Rollover Setting for incremental daily log files.

If you are interested in the Validation Application Block with Unity, you can also check out that previous screencast as well:

Enterprise Library 4.0 Validation Application Block and Unity IoC Screencast

For more information on the Logging Application Block, I have some tutorials that I wrote for Logging Application Block in Enterprise Library 2.0 that essentially still apply:

Enterprise Library Logging Application Block Part I - TraceListeners

Enterprise Library Logging Application Block Part II - Simple ASP.NET 2.0 Website Example - Logging Unhandled Exceptions

Enterprise Library Logging Application Block Part III - Programmatically Using Logging Application Block With No Configuration File

Enterprise Library Logging Application Block Part IV - Conclusion - Free .NET Tutorials and Examples

I hope the Logging Application Block Screencast proves somewhat useful.

Dave

Presenting C# 3.0 and LINQ at Sarasota Florida Visual Studio 2008 Launch Event

David Hayden — Sat, 31 May 2008 19:22:00 GMT

Feels weird to have a Visual Studio 2008, SQL Server 2008, and Windows Server 2008 launch events happening in June, but the Sarasota Florida .NET Developer Launch Event is on Saturday, June 21, 2008 at the Sarasota Community Foundation. There are not many details published yet, but unless things change, I will be presenting the new language features in C# 3.0 as well as the various flavors of LINQ. Since I have been presenting on various Visual Studio 2008 SP1 features for quite some time, expect me to sneak in Entity Framework, Astoria, and Dynamic Data whenever possible.

I haven't put the presentation together yet, but expect C# 3.0 information on:

Anonymous Types
Automatically Implemented Properties
Extension Methods
Implicitly Typed Local Variables
Lambda Expressions
Expression Trees
Object and Collection Initializers
Partial Methods

With LINQ we will probably dig into:

LINQ To Objects
LINQ To Xml
LINQ To DataSets
LINQ To SQL
LINQ To Entities

and then if possible I will briefly toss in the following topics as related to the above:

ADO.NET Entity Framework and EntityDataSource
ADO.NET Data Services ( Astoria )
ASP.NET Dynamid Data

All of this is tentative based on the amount of time in the session, etc., but I hope to see you at the Sarasota Launch Event.

David Hayden

Day of Patterns & Practices - Your Thoughts? Catch me at Party at Palermo, TechEd, Florida Tweener

David Hayden — Sat, 31 May 2008 18:46:00 GMT

I run a very humble free event, called Day of Patterns & Practices, which is a day long event in Tampa, Florida where we discuss various proven practices as well as tools and technologies that support those practices. The event has a website, called PnPGuidance, that started out as a support site for these events but has grown into a resource on Patterns & Practices in general. Although a little known fact, the Day of Patterns & Practices was the first "Day Of" event established in Florida :)

I snag two of the coolest and generous people you will ever meet on this planet, Jeff Barnes and Stan Schultes, to help me deliver material that is practical and useful to day-to-day development. Although not necessarily the goal, the event in the past has had a Microsoft Patterns & Practices focus where we talk about Enterprise Library and the numerous software factories.

For example, the first event in May 2007 focused on the following:

Enterprise Library
Smart Client Software Factory
Web Client Software Factory
Web Service Software Factory: ASMX and WCF

The second event in Jan 2008 focused on:

Web Client Software Factory 2.0
Web Service Software Factory: Modeling Edition
Test-Driven Development
ASP.NET MVC Framework

Recently with the release of Enterprise Library 4.0, ObjectBuilder 2.0, and Unity 1.1, I am already thinking about the next event with presentations such as:

Enterprise Library 4.0
ObjectBuilder 2.0
Unity 1.1
Prism ( or maybe Caliburn )

As I think about the possible topics and the timeframe of the next Day of Patterns & Practices, a few things come to mind:

I don't want to do these events too often so that they lose their value.
I worry about too much of a focus on Microsoft Patterns & Practices.
I don't know if the developer need is breadth or depth on these topics.
How can I expand this to more than just Tampa, Florida?

Since doing these events, I have received hundreds of emails from various developers, developer groups, and events both locally and internationally, to present on these topics as well as asking if I offered training or had an event schedule where I might be traveling on these topics. Truth be told, although I consult and present on these topics to clients, the Day of Patterns & Practices Event is just a once or twice a year event that has been focused in Tampa, Florida ( closest Microsoft venue to my house :). I prefer to keep them free, informal, but very pragmatic and useful for day-to-day development.

The original idea was to present these topics as more of a road show across Florida, but If you aren't familiar with the Florida .NET Developer Community, we literally have code camps, developer groups meetings, geek luncheons, geek laagers, "Day Of" events, launch events, pub clubs, etc. happening all the time. Florida is a very close knit and busy .NET Developer Community which makes it difficult to find the time and a venue for the Day of Patterns & Practices Events, because the presenters present at other events all across Florida. You can thank the very cool Joe Healy, Russ Fustino, Dave Noderer, Shawn Weisfield, etc. and others that suport the cool development environment. Btw, Kyle Baley's Bahama .NET Developer Group is an honorary Florida .NET Developer Group :)

That being said, I will be at TechEd 2008, the Florida Tweener, and Party at Palermo in Orlando next week and I would love to hear from others as to what you would like to see from the Day of Patterns & Practices Event.

What would you like to see as the next topics?
Are you looking for breadth or in-depth talks?
Would you prefer a single day event, multiple days, or possibly a series of evening events?
Would you be interested in a Day of Patterns & Practices - ALT.NET Version?
How often would you like these events?
Would you prefer it to be run as a paid course event with more structure?
Would you like to see it in your city?

I would love to talk with other developers next week about anything :) as well as what you would like to see from the Day of Patterns & Practices Event. I am considering the next event to be in August in Tampa, Florida with the above presentations, but I am open to ideas and feedback. If you are interested in speaking, I am also always looking for knowledgeable developers to talk on such topics.

See you next week,

Dave

ReSharper Introspection Severity and the var Keyword

David Hayden — Thu, 29 May 2008 17:38:00 GMT

I flagged a blog post the other day from a news feed where someone implied that they had removed ReSharper 4.0 Beta because they did not agree with the ReSharper 4.0 hints regarding the use of the var keyword. If you install the ReSharper 4.0 beta and don't change any of the Introspection Settings in the options, ReSharper will offer you the hint of using the var keyword when declaring variables, etc. It may seem like a suggestion, warning, or even an error when you see the little squiggle, but hey, it's a hint.

Now the beauty about these little hints, suggestions, etc. is that they teach you a little about what is possible in your programming language. Maybe you didn't realize the var keyword existed and when you could and could not take advantage of it. Better yet, and here is the real kicker, you have the option of adjusting the settings:

Therefore based on your coding standards and beliefs, you have the ability to personally adjust the settings for the various hints, suggestions, warnings, errors, etc. So before you jump into the mistake of un-installing ReSharper ( or any tool ) on such a coding style disagreement, you may want to see if you can adjust the settings to your particular style :)

EntLib 4.0 Validation Application Block and Unity Screencast

David Hayden — Tue, 27 May 2008 03:05:00 GMT

In my last screencast I talked about integrating the Data Access Application Block with Unity:

Enterprise Library 4.0 Data Access Application Block ( DAAB ) and Unity IoC Screencast

In the following screencast on the Validation Application Block in Enterprise Library 4.0:

Enterprise Library 4.0 Validation Application Block and Unity IoC Screencast

we don't need to discuss Unity Extensions like in the previous screencast, because we can get really nice injection of validator classes, such as IValidator<Customer>, into our custom classes by creating a simple wrapper around the Validation Application Block and registering the wrapper with Unity.

The screencast shows how to create a simple wrapper around the Validation Application Block, register it with Unity.RegisterType, access the custom validator classes via Unity.Resolve, and have Unity inject those validator classes into custom classes, such as an AddCustomerPresenter Class. The same techniques will work if you are using the ASP.NET MVC Framework and injecting validator classes into a Controller.

For more information on the Validation Application Block:

Validation Application Block in Enterprise Library 3.0 - Using Validation Facade Class - Part I

Validation Application Block in Enterprise Library 3.0 - ValidationFactory Class - Part II

Validation Application Block Ruleset in Enterprise Library 3.0 - Enterprise Library 3.0 Tutorials - Part III

Validation Application Block - Rules in External XML Configuration File - App.Config Web.Config - Enterprise Library 3.0 - Part IV

You can also check out my Unity Dependency Injection Screencasts:

Thanks for all the positive feedback on the previous screencast :) Enjoy!

David Hayden

Enterprise Library 4.0 DAAB with Unity Screencast

David Hayden — Tue, 20 May 2008 19:44:00 GMT

I received a few requests for a screencast to go along with my tutorial:

Enterprise Library 4.0 Data Access Application Block ( DAAB ) and Unity IoC Tutorial - DataAccessBlockExtension

so I went ahead and cooked one up:

Enterprise Library 4.0 Data Access Application Block ( DAAB ) and Unity IoC Screencast

The screencast walks you through creating a console application that uses the Enterprise Library 4.0 Data Access Application Block for use with Unity. I show how to obtain database classes using Unity.Resolve<Database> as well as how to inject the database classes into your custom classes ( CustomerDAO in this case ).

I discuss a couple of the Unity Extension Classes, EnterpriseLibraryCoreExtension and DataAccessBlockExtension, and jump into Reflector to show you what the DataAccessBlockExtension is doing behind the scenes.

You might want to take a peek at my article on the DatabaseConfigurationView Class to get more information on how the DataAccessBlockExtension gets access to the Data Access Application Block Configuration Information to populate the UnityContainer:

DatabaseConfigurationView Class in Enterprise Library Data Access Application Block - Read Database Connection Strings and Configuration

I hope the screencast is useful. Feel free to browse through any of the other screencasts as well.

Unity 1.1 Released and Included in Enterprise Library 4.0

David Hayden — Mon, 19 May 2008 04:33:00 GMT

Nothing scarier than hearing about Unity 1.1 being released after Enterprise Library 4.0, but rest assured Unity 1.1 is included with Enterprise Library 4.0.

Unity 1.1 fixes a few bugs and has other enhancements:

Removal of all obsolete ObjectBuilder code.

Fix for a bug when using lifetime managers with open generic types.

Fix for a bug where the RegisterType method was overriding the RegisterInstance method.

Performance improvement when resolving singletons.

Exposure of some additional internal classes as public to make it easier write extensions that need to resolve dependencies in a customized way.

Addition of try...catch blocks to improve the error messages returned when value resolution fails.

You can download Unity 1.1 here.

More importantly, however, I had a chance to play with Enterprise Library 4.0 and Unity this evening and created a tutorial that shows you how to use Unity with the Data Access Application Block:

Enterprise Library 4.0 Data Access Application Block ( DAAB ) and Unity IoC Tutorial - DataAccessBlockExtension

The other application blocks work similarly so hopefully the tutorial gives you an idea on how it all works.

Enterprise Library 4.0 Released with Unity IoC Integration

David Hayden — Sat, 17 May 2008 03:20:00 GMT

I was wondering just the other day when Enterprise Library 4.0 might be released and low and behold today was the day.

There are no new application blocks with Enterprise Library 4.0, but there are a few enhancements to existing blocks and the much anticipated Unity IoC Integration. If you so desire, you can now use Unity to wire up your application blocks when using Enterprise Library in your applications. This is, of course, optional. You can use the existing configuration model that has been at the core of Enterprise Library since 2.0 and replaced the Configuration Application Block.

You can download Enterprise Library 4.0 here. I recommend you visit the landing page to learn about all the particulars of Enterprise Library 4.0.

If you are a veteran Enterprise Library developer, it is essentially business as usual unless you choose to use Unity for configuration and you haven't played with it yet. For more information on Unity, I have a couple of Unity Screencasts and a number of Unity Tutorials on PnPGuidance:

Unity Dependency Injection IoC Screencast

Unity IoC - Dependency Injection in ASP.NET MVC Framework Screencast

Unity is pretty simple to use as dependency injection / IoC tools go.

Over the years I have probably written well over 50 - 100 tutorials on Enterprise Library. Down right pathetic as to how much I have written on Enterprise Library actually :) It was a great learning experience, however. For the most part all of the tutorials still apply, so if you are just learning Enterprise Library feel free to go through them. Even though I broke them down into Enterprise Library 2.0 Tutorials and Enterprise Library 3.0 Tutorials, the information is still accurate for Enterprise Library 4.0 with possibly a few exceptions.

I often get asked where to start with all the tutorials, so I usually just point people to the following introductory tutorials that focus on the fundamentals for about each application block.

You can also find some Enterprise Library Tutorials on PnPGuidance.

Hope this helps,

Dave

Visual Studio 2008 SP1 "Background Compiling" for C#

David Hayden — Tue, 13 May 2008 18:41:00 GMT

I don't know the proper term for the new functionality in Visual Studio 2008 SP1 for C# that does code anaysis and finds compilation errors without an explicit compile ( what I would term "Background Compilation" ), but Scott Guthrie provides the following description:

"The C# code editor now identifies and displays red squiggle errors for many semantic code issues that previously required an explicit compilation to identify. For example, if you try to declare and use an unknown type in the C# code-editor today you won't see a compile error until you do a build. Now with SP1 you'll see live red squiggle errors immediately (no explicit compile required):"

Holy time savings Batman, this is much needed functionality for those developers who are not using ReSharper or another tool that provides similar code analysis in the background. I had to jump on my development machine that is not running the Visual Studio 2008 SP1 Beta just to make sure this background compilation wasn't already being done in Visual Studio 2008.

I didn't put the feature through a thorough testing, but I was just happy that it would identify unknown classes and other little things. The red squiggles are a huge time saver.

This is worth Visual Studio 2008 SP1 alone. And, no, I don't know what performance impact this has on large projects :)

Recent Visual Studio 2008 SP1 Beta Posts: