David Hayden

Auto-Generated Factories in Autofac for Lazy Instantiation - LazyDependencyModule

Auto-Generated Factories in Autofac 2 is a brilliant addition to Autofac. The concept is simple. Often a service / class has dependencies that are relatively expensive to instantiate and may or may not be used by the service. Rather than instantiating the dependency during service construction, the container provides a lazy container, Func<T> or Lazy<T> for example, during construction that provides a way to access the dependency and instantiate it only at time of use. One can easily create the lazy containers in code, but Auto-Generated Factories in Autofac 2 give you this functionality for free!

Auto-Generated Factories in Autofac using Lazy<T>

Since I’ve been going on and on about Lazy<T> and Lazy<T,TMetadata> in .NET 4, it only makes sense that I beat the subject to death again :)

The NewsController below has a dependency of Lazy<IEnumerable<IPublisher>> because the instantiation of various publishers to publish the news is an expensive process and may or may not be used by the controller depending on the action called by the client.

Using Auto-Generated Factories in Autofac we only have to register the various publishers and add the LazyDependencyModule to the ContainerBuilder for Autofac to magically create the Lazy<T> container needed by the NewsController.

Here is some simple code to illustrate the idea:

class Program
{
 static void Main(string[] args)
 {
  var builder = new ContainerBuilder();

  // Module in Autofac.Integration.Mef
  builder.RegisterModule(new LazyDependencyModule());

  // Native Collection Support in Autofac 2!!
  builder.RegisterType<NewsPublisher1>().As<IPublisher>();
  builder.RegisterType<NewsPublisher2>().As<IPublisher>();

  builder.RegisterType<NewsController>();

  var container = builder.Build();

  var controller = container.Resolve<NewsController>();

  controller.Publish(new News());
 }
}

public class NewsController
{
 Lazy<IEnumerable<IPublisher>> _publishers;

 public NewsController(Lazy<IEnumerable<IPublisher>> publishers)
 {
  _publishers = publishers;
 }

 public void Publish(News news)
 {
  _publishers.Value.ToList().ForEach(p => p.Publish(news));
 }

}

Notice how Autofac automatically injects a Lazy<IEnumerable<IPublisher>> dependency for us. That is slick!

Auto-Generated Factories in Autofac using Func<T>

We can’t always count on using the .NET Framework 4.0, so let Auto-Generated Factories in Autofac 2 inject a Func<IEnumerable<IPublisher>> dependency with a few minor changes to the code:

class Program
{
 static void Main(string[] args)
 {
  var builder = new ContainerBuilder();

  // Native Collection Support in Autofac 2!!
  builder.RegisterType<NewsPublisher1>().As<IPublisher>();
  builder.RegisterType<NewsPublisher2>().As<IPublisher>();

  builder.RegisterType<NewsController>();

  var container = builder.Build();

  var controller = container.Resolve<NewsController>();

  controller.Publish(new News());
 }
}

public class NewsController
{
 Func<IEnumerable<IPublisher>> _publishers;

 public NewsController(Func<IEnumerable<IPublisher>> publishers)
 {
  _publishers = publishers;
 }

 public void Publish(News news)
 {
  _publishers().ToList().ForEach(p => p.Publish(news));
 }

}

That's just wicked cool!

Conclusion

Auto-Generated Factories is a really nice feature in Autofac 2. If you haven’t played with Autofac and are interested in a lightweight and user friendly IoC Container, you owe it to yourself to download the source and check out the group.

Next time I will show you how these Auto-Generated Factories inspired similar functionality in Unity 2 :)

Hope this helps.

David Hayden

Lazy(T, TMetadata) Class in System.ComponentModel.Composition

I talked about Lazy<T> in .NET 4, which is a pretty cool way to handle multi-threaded access to shared resources that are expensive to create. It does the equivalent of double-check locking to make sure that a resource is only instantiated once.

Most of use know about Lazy<T>, but did you know about Lazy<T,TMetadata> in System.ComponentModel.Composition? I didn’t until last night and I think it is pretty darn cool when you want to interrogate some Metadata to decide if you really want to instantiate the resource.

Lazy<T,TMetadata>

Let’s take a hypothetical situation where we have a number of Publisher Services that publish news on our behalf, but they are expensive to instantiate and we really only want to do this if they are indeed online.

We create two interfaces that represent the publisher service and its metadata as such:

public interface IPublisher
{
 void Publish(News news);
}

public interface IPublisherMetadata
{
 bool Online { get; }
}

We can now use these interfaces in a collection of Lazy<IPublisher,IPublisherMetadata> in say a NewsController that is responsible for handling the publishing of news. Inside the actual Publish Action we interrogate the IPublisherMetaData and only instantiate and call those publishers that indeed are online as such:

public class NewsController
{
 private readonly IEnumerable<Lazy<IPublisher, IPublisherMetadata>> _publishers;

 public NewsController(IEnumerable<Lazy<IPublisher, IPublisherMetadata>> publishers)
 {
 _publishers = publishers;
 }

 public void Publish(News news)
 {
 var publishers = _publishers.Where(p => p.Metadata.Online).ToList();
 publishers.ForEach(p => p.Value.Publish(news));
 }
}

This is brilliant. The Lazy<T,TMetadata> Class will be very handy in those scenarios where you have a number of expensive services that could achieve some end result but you want to filter them based on some configuration setting or runtime value. Very cool.

David Hayden

Tuple.Rest Property and Nested Tuples with C# 4

In an earlier post, Tuples in C# 4, a developer asked about tuples with 8 or more items and the idea of nested tuples.

The .NET Framework 4 only supports tuples with up to 8 items and the last item is expected to be a nested Tuple and is represented by the Rest property. Per the documentation:

“The Rest property returns a nested Tuple object that allows access to the eighth though nth components of the tuple.”

Here is a quick example of creating a Tuple and Nested Tuple with a total of 12 items and accessing items 8 through 12 via the Tuple.Rest Property. To Keep things simple we will just deal with integers.

var nestedTuple = new Tuple<int,int,int,int,int>(8,9,10,11,12);

var myTuple = new Tuple<int,int,int,int,int,int,int,Tuple<int,int,int,int,int>>
(1, 2, 3, 4, 5, 6, 7, nestedTuple);

var seven = myTuple.Item7; // 7

var eight = myTuple.Rest.Item1; // 8

var nine = myTuple.Rest.Item2; // 9

var ten = myTuple.Rest.Item3; // 10

var eleven = myTuple.Rest.Item4; // 11

var twelve = myTuple.Rest.Item5; // 12

Notice how the nested Tuple is represented by the Tuple.Rest Property and you access its items using the familiar Item1, Item2, etc. properties. I wish there was a more elegant way to pull this off, but I don’t know of one. And, as far as I know, there is no way to name the properties on a Tuple other than Item1, Item2, etc.

It would have been really nice if the C# team would have made working with Tuples a bit more elegant.

Hope this helps.

David Hayden

LINQ Zip - Merge Two Sequences Using Predicate Function

LINQ has a new extension method in the .NET Framework 4, called Zip, that exists on both IEnumerable<T> and IQueryable<T>. Zip is a neat Extension Method that allows one to merge two sequences into a single sequence using a predicate function.

IEnumerabe<T>.Zip

Let’s use the new LINQ Zip Extension Method in LINQ To Objects to merge two sequences using a predicate function. The first sequence will contain the names of the months of the year. The second sequence will contain the number of days in each month for 2009. We will combine those two sequences into a sentence that says “January has 31 days”, where January and 31 will be replaced by the appropriate month name and number of days in the sequences.

Here is the sample C# code that creates the two sequences, merges them using the new LINQ Zip Extension Method, and displays them on the console:

// Get Names of Months
var months = from i in Enumerable.Range(1, 12)
       select new DateTime(2009,i,1).ToString("MMMM");

// Get Number of Days in Each Month
var daysInMonths = from i in Enumerable.Range(1, 12)
       select DateTime.DaysInMonth(2009,i).ToString();

// Combine
var combined = months.Zip(daysInMonths, (month, day)
  => string.Format("{0} has {1} days", month,day));

// Display
combined.ToList().ForEach(d => Console.WriteLine(d));

Console.ReadLine();

You could achieve the same thing using existing LINQ Extension Methods, but having such an extension method clearly shows your intentions and thus allows for better performance and other optimizations that can be achieved in the underlying framework.

The results is as follows:

Hope this helps!

CustomValidation Attribute and ASP.NET MVC Validation

I love uncovering new features and enhancements in the .NET Framework 4 and C# 4. In fact you will find that a great deal of my blog posts thus far have been about sharing features I find using Visual Studio 2010 and .NET Framework 4.

If you are playing with ASP.NET DynamicData, RIA Services, ASP.NET MVC Framework, etc., you will no doubt be familiar with the System.ComponentModel.DataAnnotations Namespace as it relates to validating your view models, entities, and business objects in your .NET Applications.

The DataAnnotations Namespace has a number of attributes that are used to decorate your classes and properties with metadata. In terms of validation, you will find attributes such as RangeAttribute, RegularExpressionAttribute, RequiredAttribute,StringLengthAttribute, etc.

A new attribute available for .NET Framework 4 is the CustomValidationAttribute.

CustomValidation Attribute

The CustomValidation Attribute is a nice alternative to subclassing the ValidationAttribute to call custom validation code associated with a property, method, type, field, or method parameter. The CustomValidation Attribute takes two properties in its constructor: 1) A type that holds the method to perform validation, and 2) the public static method on that type that will actually perform the validation.

Let’s take a simple example where we want to validate the email address on a type such that it does not accept a free “hotmail” account for people who subscribe to the website newsletter.

Using ASP.NET MVC 2.0, there is a Subscribe Action on my controller that takes SubscribeRequest as a parameter:

[HttpPost]
public ActionResult Subscribe(SubscribeRequest request)
{
  if (!ModelState.IsValid)
    return View();

  // Do Something...
}

As I had discussed in another post, the DefaultModelBinder supports System.ComponentModel.DataAnnotations out of the box ( as well as IDataErrorInfo ) so we can decorate SubscribeRequest with various ValidationAttributes. If the validation fails, ModelState.IsValid will return false and the view will be re-displayed with the errors.

Here is an example of SubscribeRequest with a RequiredAttribute and the CustomValidationAttribute:

public class SubscribeRequest
{
  [Required]
  [CustomValidation(typeof(EmailAddressValidator), "Validate")]
  public string EmailAddress { get; set; }
}

The CustomValidation Attribute specifies that a separate type, EmailAddressValidator, and a public static method, Validate, perform the validation.

public static class EmailAddressValidator
{
  public static ValidationResult Validate(string emailAddress, ValidationContext context)
  {
    if (emailAddress != null && emailAddress.Contains("hotmail"))
      return new ValidationResult("No Free Accounts", new[] { "EmailAddress" });

    return ValidationResult.Success;
  }
}

The method returns a ValidationResult, which is either ValidationResult.Success if validation is successful or a new ValidationResult with the error message and list of properties with errors returned as IEnumerable<string>.

For more information on the method parameters, ValidationContext, and ValidationResult, you should familiarize yourself with the preliminary documentation.

When validation is unsuccessful the error is appropriately displayed on the page:

You can check out other ASP.NET MVC 2 Tutorials.

Hope this helps.

String.IsNullOrWhiteSpace - .NET Framework 4 Visual Studio 2010

If you have been spending anytime developing for the .NET Framework 4 in Visual Studio 2010, you may have noticed a new static method on the string class, called IsNullOrWhiteSpace, in addition to the more familiar IsNullOrEmpty method.

In many instances String.IsNullOrEmpty() really wasn’t that helpful as it didn’t return true if the string only included whitespace characters ( characters that were not visible on the screen ). In most instances a string full of whitespace characters can be considered an empty string.

To help with this situation, .NET Framework 4 has included a String.IsNullOrWhiteSpace() method that will return true if a string is full of whitespace characters. Let’s take the example below where there is an input string with a space, carriage return, linefeed and tab.

Calling String.IsNullOrEmpty(input) on that string will return false as the string is not null and it is not empty. However, calling String.IsNullOrWhiteSpace(input) will return true as the string is indeed full of whitespace characters.

class Program
{
  static void Main(string[] args)
  {
    string input = " \r\n\t";

    if (string.IsNullOrEmpty(input))
      Console.WriteLine("This won't display.");

    if (string.IsNullOrWhiteSpace(input))
      Console.WriteLine("This will display");

    Console.ReadLine();
  }
}

The String.IsNullOrWhiteSpace() Method is a nice addition to .NET Framework 4 which you can use in Visual Studio 2010.

Lazy<T> in .NET 4.0 Framework

Lazy<T> is new in the .NET 4.0 Framework and is more of a helper class for handling multi-threaded access to shared resources that are expensive to create. To keep from creating these shared resources multiple times, one often did some sort of double-check locking to see if the resource was already being created by one thread before having another thread attempt to create it again.

Let's take the example of a Database Class that has a shared resource of all databases on the network. Let's assume getting the list of databases on the network is or could be a very expensive operation and we only want to do this once.

Double-Check Locking

To synchronize access to this shared resource and make sure the databases are only discovered once, we will handle resource synchronization with double-check locking the ol' fashioned way:

public class Database
{
 private static DatabaseCollection _databasesOnNetwork;
 private static Object _sync = new object();

 public DatabaseCollection DatabasesOnNetwork
 {
  get 
  {
   // Double-Check Locking
   if (_databasesOnNetwork == null)
   {
    lock (_sync)
    {
     if (_databasesOnNetwork == null)
      _databasesOnNetwork = GetListOfDatabasesOnNetwork();
    }
    }

    return _databasesOnNetwork;
   }
  }

  private static DatabaseCollection GetListOfDatabasesOnNetwork()
  {
   // An Obvious Simplification
   return new DatabaseCollection();
  }
 }

 public class DatabaseCollection { }

This works pretty well and makes sure GetListOfDatabasesOnNetwork() is called only once.

Lazy<T> in .NET 4.0 Framework

Lazy<T> will handle this for us with much less code. By default, Lazy<T> is thread-safe unless you turn it off. We can rewrite the code above as follows using Lazy<T>. Notice I am passing in a Function<T> as part of the Lazy<T> Constructor to tell it how to create the DatabaseCollection.

public class Database
{
 private Lazy<DatabaseCollection> _databasesOnNetwork
   = new Lazy<DatabaseCollection>(() => GetListOfDatabasesOnNetwork());

 public DatabaseCollection DatabasesOnNetwork
 {
  get 
   {
    return _databasesOnNetwork.Value;
   }
  }

  private static DatabaseCollection GetListOfDatabasesOnNetwork()
  {
   // An Obvious Simplification
   return new DatabaseCollection();
  }
 }

 public class DatabaseCollection { }

Notice all of that ugly double-check locking code is gone, gone, gone! It is now encapsulated inside the Lazy<T> Class.

You can check out some other recent tutorials on C# 4.0:

• Creating Wrappers with Dynamic Keyword and DynamicObject in C# 4
• ExpandoObject in C# 4