42

Random thoughts filtered through a babelfish.

Extending and Demonstrating the Type Tracking Extension for Unity

Categories: Programming

Tags: ALT.NET, Dependency Injection, IoC, Programming, Unity

Comments: 14 Comments

Published on: August 20, 2009

Recently, I have received a few requests for some changes and an example for my Type Tracking Extension for Unity. This post is to address those requests. Of course, all of the source code for this post is added to the GitHub project Unity Extensions.

Part One – Extension Methods for the Type Tracking Extension

The number one request I have received, and my own number one issue with using the Type Tracking Extension, is the verbosity of each method call. Here is a typical method call.

   1: container.Configure<TypeTrackingExtension>().TryResolve<ITest>();

This is the typical extension usage model for Unity. Besides the verbosity, it implies that I am configuring the extension, when I am just trying to use it. I try to avoid code that implies something other than what I intend, so this syntax bothers me.

To address this issue, I have added a new class of extension methods to the Type Tracking project. Here is the source code.

namespace hazware.unity.extensions
{
  /// <summary>
  /// Extension methods to simplify using the TypeTrackingExtension for Unity.
  /// Requires .NET 3.5
  /// </summary>
  public static class UnityExtensions
  {
    #region CanResolve
    /// <summary>
    /// Determines whether this type can be resolved as the default.
    /// </summary>
    /// <typeparam name="T">The type to test for resolution</typeparam>
    /// <param name="container">The unity container.</param>
    /// <returns>
    ///     <c>true</c> if this instance can resolve; otherwise, <c>false</c>.
    /// </returns>
    public static bool CanResolve<T>(this IUnityContainer container)
    {
      return container.Configure<TypeTrackingExtension>().CanResolve<T>();
    }
    /// <summary>
    /// Determines whether this type can be resolved with the specified name.
    /// </summary>
    /// <typeparam name="T">The type to test for resolution</typeparam>
    /// <param name="container">The unity container.</param>
    /// <param name="name">The name associated with the type.</param>
    /// <returns>
    ///     <c>true</c> if this instance can resolve; otherwise, <c>false</c>.
    /// </returns>
    public static bool CanResolve<T>(this IUnityContainer container, string name)
    {
      return container.Configure<TypeTrackingExtension>().CanResolve<T>(name);
    }
    /// <summary>
    /// Determines whether this instance can be resolved at all with or without a name.
    /// </summary>
    /// <typeparam name="T">The type to test for resolution</typeparam>
    /// <param name="container">The unity container.</param>
    /// <returns>
    ///     <c>true</c> if this instance can resolve; otherwise, <c>false</c>.
    /// </returns>
    public static bool CanResolveAny<T>(this IUnityContainer container)
    {
      return container.Configure<TypeTrackingExtension>().CanResolveAny<T>();
    }
    #endregion
  
    #region TryResolve
    /// <summary>
    /// Tries to resolve the type, returning null if not found.
    /// </summary>
    /// <typeparam name="T">The type to try and resolve</typeparam>
    /// <param name="container">The unity container.</param>
    /// <returns>An object of type <see cref="T"/> if found, or <c>null</c> if not.</returns>
    public static T TryResolve<T>(this IUnityContainer container)
    {
      return container.Configure<TypeTrackingExtension>().TryResolve<T>();
    }
    /// <summary>
    /// Tries to resolve the type with the specified of name, returning null if not found.
    /// </summary>
    /// <typeparam name="T">The type to try and resolve</typeparam>
    /// <param name="container">The unity container.</param>
    /// <param name="name">The name associated with the type.</param>
    /// <returns>An object of type <see cref="T"/> if found, or <c>null</c> if not.</returns>
    public static T TryResolve<T>(this IUnityContainer container, string name)
    {
      return container.Configure<TypeTrackingExtension>().TryResolve<T>(name);
    }
    /// <summary>
    /// Tries to resolve the type, returning the passed in defaultValue if not found.
    /// </summary>
    /// <typeparam name="T">The type to try and resolve</typeparam>
    /// <param name="container">The unity container.</param>
    /// <param name="defaultValue">The default value.</param>
    /// <returns>An object of type <see cref="T"/> if found, or the <see cref="defaultValue"/> if not.</returns>
    public static T TryResolve<T>(this IUnityContainer container, T defaultValue)
    {
      return container.Configure<TypeTrackingExtension>().TryResolve<T>(defaultValue);
    }
    /// <summary>
    /// Tries to resolve the type, returning the passed in defaultValue if not found.
    /// </summary>
    /// <typeparam name="T">The type to try and resolve</typeparam>
    /// <param name="container">The unity container.</param>
    /// <param name="name">The name associated with the type.</param>
    /// <param name="defaultValue">The default value.</param>
    /// <returns>An object of type <see cref="T"/> if found, or the <see cref="defaultValue"/> if not.</returns>
    public static T TryResolve<T>(this IUnityContainer container, string name, T defaultValue)
    {
      return container.Configure<TypeTrackingExtension>().TryResolve<T>(name, defaultValue);
    }
    #endregion
  
    #region ResolveAll
    /// <summary>
    /// Resolves all elements of a type, including the default.
    /// </summary>
    /// <typeparam name="T">The type to resolve</typeparam>
    /// <param name="container">The unity container.</param>
    /// <returns><see cref="IEnumerable"/> of T</returns>
    public static IEnumerable<T> ResolveAllToEnumerable<T>(this IUnityContainer container)
    {
      return container.Configure<TypeTrackingExtension>().ResolveAll<T>();
    }
    /// <summary>
    /// Resolves all registered T in the container, conditionally including the default unnamed
    /// registered T. When includeDefault is false, this is the same as the normal Unity
    /// ResolveAll.
    /// </summary>
    /// <typeparam name="T">The type to resolve</typeparam>
    /// <param name="container">The unity container.</param>
    /// <param name="includeDefault">if set to <c>true</c> include default value, else do not include default.</param>
    /// <returns><see cref="IEnumerable"/> of T</returns>
    public static IEnumerable<T> ResolveAllToEnumerable<T>(this IUnityContainer container, bool includeDefault)
    {
      return container.Configure<TypeTrackingExtension>().ResolveAll<T>(includeDefault);
    }
    /// <summary>
    /// Resolves all elements of a type, including the default, and returns 
    /// as an array of T.
    /// </summary>
    /// <typeparam name="T">The type to resolve</typeparam>
    /// <param name="container">The unity container.</param>
    /// <returns>Array of T</returns>
    public static T[] ResolveAllToArray<T>(this IUnityContainer container)
    {
      return container.Configure<TypeTrackingExtension>().ResolveAllToArray<T>();
    }
    /// <summary>
    /// Resolves all registered T in the container, conditionally including the default unnamed
    /// registered T. When includeDefault is false, this is the same as the normal Unity
    /// ResolveAll.
    /// </summary>
    /// <typeparam name="T">The type to resolve</typeparam>
    /// <param name="container">The unity container.</param>
    /// <param name="includeDefault">if set to <c>true</c> include default value, else do not include default.</param>
    /// <returns>Array of T</returns>
    public static T[] ResolveAllToArray<T>(this IUnityContainer container, bool includeDefault)
    {
      return container.Configure<TypeTrackingExtension>().ResolveAllToArray<T>(includeDefault);
    }
    #endregion
  }
}

Using these extension methods makes the above sample code look like this:

   1: container.TryResolve<ITest>();

This is more concise, and more importantly, clearly states the meaning of the code. However, the catch for this syntactic sugar is that it uses extension methods. That means that .NET 3.5 is now a requirement for the Type Tracking Extension.

Part Two – Type Tracking Usage Sample

I have received a few requests for a simple example of how to use the Type Tracking Extension. So here it is.

Step 1 – Add a reference to the hazware.unity.extensions assembly into your project.

Step 2 – Add the following using statement to your source file:

   1: using hazware.unity.extensions;

Step 3 – Register the extension with the Unity container. Here is some sample code:

   1: IUnityContainer container = new UnityContainer();
   2: container.AddNewExtension<TypeTrackingExtension>();

Step 4 – Use the extension. Here some more sample code:

   1: Console.WriteLine("CanResolve<IFoo>() == {0}", container.CanResolve<IFoo>());
   2: Console.WriteLine("CanResolve<IBar>() == {0}", container.CanResolve<IBar>());

That’s it. So here is a complete sample program.

class Program
{
  static void Main(string[] args)
  {
    IUnityContainer container = new UnityContainer();
    container.AddNewExtension<TypeTrackingExtension>();
  
    container.RegisterType<IFoo, AFoo>();
    container.RegisterType<IFoo, AnotherFoo>("Named");
  
    Console.WriteLine("CanResolve<IFoo>() == {0}", container.CanResolve<IFoo>());
    Console.WriteLine("CanResolve<IFoo>(\"Named\") == {0}", container.CanResolve<IFoo>("Named"));
    Console.WriteLine("CanResolve<IBar>() == {0}", container.CanResolve<IBar>());
  
    Console.WriteLine("TryResolve<IFoo>() == null ==> {0}", container.TryResolve<IFoo>() == null);
    Console.WriteLine("TryResolve<IFoo>(\"Named\") == null ==> {0}", container.TryResolve<IFoo>("Named") == null);
    Console.WriteLine("TryResolve<IBar>() == null ==> {0}", container.TryResolve<IBar>() == null);
    
    Console.WriteLine("TryResolve<IBar>(new ABar()) == null ==> {0}", container.TryResolve<IBar>(new ABar()) == null);
    Console.WriteLine("TryResolve<IBar>(\"Named\", new ABar()) == null ==> {0}", container.TryResolve<IBar>("Named", new ABar()) == null);
  
    Console.WriteLine("ResolveAllToEnumerable<IFoo>().Count() == {0}", container.ResolveAllToEnumerable<IFoo>().Count());
    Console.WriteLine("ResolveAllToEnumerable<IFoo>(false).Count() == {0}", container.ResolveAllToEnumerable<IFoo>(false).Count());
    Console.WriteLine("ResolveAllToEnumerable<IBar>().Count() == {0}", container.ResolveAllToEnumerable<IBar>().Count());
  
    Console.WriteLine("ResolveAllToArray<IFoo>().Length == {0}", container.ResolveAllToArray<IFoo>().Length);
    Console.WriteLine("ResolveAllToArray<IFoo>(false).Length == {0}", container.ResolveAllToArray<IFoo>(false).Length);
    Console.WriteLine("ResolveAllToArray<IBar>().Length == {0}", container.ResolveAllToArray<IBar>().Length);
  }
}

This source is in the SampleApp project checked into the Unity Extensions project up on GitHub.

Hopefully, the extension methods make using the Type Tracking Extension easier to use, and the sample helps to demonstrates its usage.

Technorati Tags: Unity,Programming,ALT.NET,IoC,Dependency Injection

14 Comments - Leave a comment

Allen says:

June 8, 2011 at 1:56 pm

Appears that if the RegisterEventArgs to event OnNewType do not have a value for e.TypeFrom, bad things happen. I solved this in my own way by simply changing all the RegisterType statements to look like:
…RegisterType();
instead of
…RegisterType();

to avoid this error.

viz

private void OnNewType(object sender, RegisterEventArgs e)
{
HashSet names;
string name = string.IsNullOrEmpty(e.Name) ? string.Empty : e.Name;
if (e.TypeFrom == null)
throw new ArgumentNullException(“The TypeFrom argument cannot be null – use .RegisterType(); instead of
…RegisterType(); to avoid this error”);
if (!_registeredTypes.TryGetValue(e.TypeFrom, out names))
{ // not found, so add it
_registeredTypes.Add(e.TypeFrom, new HashSet(new string[] { name }));
}
else
{ // already added type, so add name
names.Add(name);
}
}

Reply
- david says:
  
  June 16, 2011 at 10:20 pm
  
  Can you provide a test case that causes this problem? I would like to add it to the unit tests and then I can verify the solution you provided and add it in.
  
  Reply
Allen says:

June 8, 2011 at 1:58 pm

RegisterType(&lt T,T &gt) is what was supposed to show up. !!!

Reply
Allen says:

June 8, 2011 at 1:58 pm

Dang! Anyway, pass from and to types to register type!!!

Reply
Allen says:

July 25, 2011 at 6:36 am

Sorry for the lack of clarity here. Let me see if I can put in the right example.

Reply
- david says:
  
  July 25, 2011 at 8:02 am
  
  Thanks
  
  Reply
Allen says:

September 23, 2011 at 11:21 am

So I see that I failed to send you an example to test with. My bad. Somewhere in my calling code I was passing a null for the type to the RegisterType() of Unity, which will raise an ArgumentNullException. So I am trapping it in this extension handler in order to not blow up with no message. Since all my code is now much more mature it is difficult to determine where I made this mistake anymore, but if you create a test passing null to one of the Unity RegisterType calls it will raise the ArgumentNullException here and then all is not well….

private void OnNewType(object sender, RegisterEventArgs e) { HashSet names; string name = string.IsNullOrEmpty(e.Name) ? string.Empty : e.Name; if (e.TypeFrom == null) throw new ArgumentNullException("The TypeFrom argument cannot be null – use .RegisterType(,); instead of …RegisterType(); to avoid this error");
if (!_registeredTypes.TryGetValue(e.TypeFrom, out names)) { // not found, so add it _registeredTypes.Add(e.TypeFrom, new HashSet(new string[] { name })); } else { // already added type, so add name names.Add(name); }

Reply
- Allen says:
  
  September 23, 2011 at 11:24 am
  
  Once again I have failed to get the arguments to show up.
  
  RegisterType( <T>,<T> )
  
  Reply
- david says:
  
  September 23, 2011 at 12:02 pm
  
  Thanks Allen. I will see if I can create a test case to reproduce.
  
  Reply
  - david says:
    
    September 23, 2011 at 12:04 pm
    
    Raised as Issue # 1 (https://github.com/dbuksbaum/unity.extensions/issues/1)
    
    Reply
Allen says:

September 23, 2011 at 11:50 am

On another note, is there some way to get rid of these compiler warnings?

BTW: For my own reasons, I have put your extensions into my Helpers namespace but otherwise this is the same UnityExtensions.cs and TypeTrackingExtensions.cs. If you are not comfortable with that I will go change the namespace references throughout.

Helpers\TypeTrackingExtension.cs(52,66): warning CS1570: XML comment on ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.TypeTrackingExtension’ has badly formed XML — ‘A name contained an invalid character.’
Helpers\TypeTrackingExtension.cs(65,33): warning CS1591: Missing XML comment for publicly visible type or member ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.TypeTrackingExtension.Initialize()’
Helpers\TypeTrackingExtension.cs(71,30): warning CS1591: Missing XML comment for publicly visible type or member ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.TypeTrackingExtension.Remove()’
Helpers\TypeTrackingExtension.cs(103,30): warning CS0168: The variable ‘ex’ is declared but never used
Helpers\TypeTrackingExtension.cs(131,30): warning CS0168: The variable ‘ex’ is declared but never used
Helpers\TypeTrackingExtension.cs(208,53): warning CS1574: XML comment on ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.TypeTrackingExtension.TryResolve()’ has cref attribute ‘T’ that could not be resolved
Helpers\TypeTrackingExtension.cs(219,53): warning CS1574: XML comment on ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.TypeTrackingExtension.TryResolve(string)’ has cref attribute ‘T’ that could not be resolved
Helpers\TypeTrackingExtension.cs(230,53): warning CS1574: XML comment on ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.TypeTrackingExtension.TryResolve(T)’ has cref attribute ‘T’ that could not be resolved
Helpers\TypeTrackingExtension.cs(230,89): warning CS1574: XML comment on ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.TypeTrackingExtension.TryResolve(T)’ has cref attribute ‘defaultValue’ that could not be resolved
Helpers\TypeTrackingExtension.cs(244,53): warning CS1574: XML comment on ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.TypeTrackingExtension.TryResolve(string, T)’ has cref attribute ‘T’ that could not be resolved
Helpers\TypeTrackingExtension.cs(244,89): warning CS1574: XML comment on ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.TypeTrackingExtension.TryResolve(string, T)’ has cref attribute ‘defaultValue’ that could not be resolved
Helpers\TypeTrackingExtension.cs(260,35): warning CS1574: XML comment on ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.TypeTrackingExtension.ResolveAll()’ has cref attribute ‘IEnumerable’ that could not be resolved
Helpers\TypeTrackingExtension.cs(273,35): warning CS1574: XML comment on ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.TypeTrackingExtension.ResolveAll(bool)’ has cref attribute ‘IEnumerable’ that could not be resolved
Helpers\UnityExtensions.cs(102,53): warning CS1574: XML comment on ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.UnityExtensions.TryResolve(Microsoft.Practices.Unity.IUnityContainer)’ has cref attribute ‘T’ that could not be resolved
Helpers\UnityExtensions.cs(114,53): warning CS1574: XML comment on ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.UnityExtensions.TryResolve(Microsoft.Practices.Unity.IUnityContainer, string)’ has cref attribute ‘T’ that could not be resolved
Helpers\UnityExtensions.cs(126,53): warning CS1574: XML comment on ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.UnityExtensions.TryResolve(Microsoft.Practices.Unity.IUnityContainer, T)’ has cref attribute ‘T’ that could not be resolved
Helpers\UnityExtensions.cs(126,89): warning CS1574: XML comment on ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.UnityExtensions.TryResolve(Microsoft.Practices.Unity.IUnityContainer, T)’ has cref attribute ‘defaultValue’ that could not be resolved
Helpers\UnityExtensions.cs(139,53): warning CS1574: XML comment on ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.UnityExtensions.TryResolve(Microsoft.Practices.Unity.IUnityContainer, string, T)’ has cref attribute ‘T’ that could not be resolved
Helpers\UnityExtensions.cs(139,89): warning CS1574: XML comment on ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.UnityExtensions.TryResolve(Microsoft.Practices.Unity.IUnityContainer, string, T)’ has cref attribute ‘defaultValue’ that could not be resolved
Helpers\UnityExtensions.cs(154,35): warning CS1574: XML comment on ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.UnityExtensions.ResolveAllToEnumerable(Microsoft.Practices.Unity.IUnityContainer)’ has cref attribute ‘IEnumerable’ that could not be resolved
Helpers\UnityExtensions.cs(168,35): warning CS1574: XML comment on ‘AASHTO.ElementMigration.VisualElementMigrator.Helpers.UnityExtensions.ResolveAllToEnumerable(Microsoft.Practices.Unity.IUnityContainer, bool)’ has cref attribute ‘IEnumerable’ that could not be resolved

Reply
- david says:
  
  September 23, 2011 at 12:02 pm
  
  Looks like some errors in the formatting of the documentation. Thanks for the catch, I will try and reproduce.
  
  Reply
  - david says:
    
    September 23, 2011 at 12:05 pm
    
    Raised as Issue # 2 (https://github.com/dbuksbaum/unity.extensions/issues/2)
    
    Reply
Shirl says:

September 27, 2011 at 1:11 am

In the complicated world we live in, it’s good to find simple soluiotns.

Reply

42

Extending and Demonstrating the Type Tracking Extension for Unity

Part One – Extension Methods for the Type Tracking Extension

Part Two – Type Tracking Usage Sample

Leave a comment Cancel reply

Leave a comment
Cancel reply