Anthony Trudeau

Enterprise Library

Anthony Trudeau — Fri, 26 Jun 2009 17:49:47 GMT

The other day Lindsay Rutter with Microsoft did a webcast on the Enterprise Library. I've used the exception handling block in a few projects, but my opinion had been that the library was bloated and was low on my priority list of technologies to investigate.

The talk on dependency injection in the webcast changed my mind. I immediately got a return on my investment as I wanted a more flexible method for tracing then what is offered from the Trace class in the System.Diagnostics namespace. And most importantly I didn't want any unnecessary dependencies in my library. Basically, my library wants the ability to log, but doesn't want any responsibility for it. Here's what I did:

Added a reference to the Microsoft.Practices.Unity library. You'll need the Microsoft.Practices.ObjectBuilder2 library referenced wherever you create the unity container and inject the dependency. My library doesn't care about that. All it cares about is that whatever creates the key objects creates the dependencies.
Define the interface for classes to perform the work. I created the ILoggingHandler with methods such as LogError, LogWarning, and LogInformation.
Add a using statement for Microsoft.Practices.Unity to the code files containing your classes that you will be injecting.
Add the following code to the classes that I want to log. There are undoubtedly other ways to approach this, but this is the most simple. At first I didn't think it was very elegant to add a property to my class, but these are base classes providing a service to subclasses, so I warmed up to the idea.

[Dependency]

public ILoggingHandler LogHandler { get; set; }
Use the property within your code where necessary as in the following code.

LogHandler.LogInformation("Enter trace information here");

It's perfect for what I needed and is extremely simple to implement. When it comes to creating the logging service class I can create it and inject it from the code that hosts these classes using the following code (where DefaultLoggingHandler is my implementation of ILoggingHandler).

IUnityContainer container = new UnityContainer();
container.RegisterType<ILoggingHandler, DefaultLoggingHandler>(new ContainerControlledLifetimeManager());
MySubClass obj = container.Resolve<MySubClass>();

The optional parameter I specified in the call to RegisterType allows the object to be created as a Singleton. That means that every MySubClass object I create will use the same DefaultLoggingHandler.

I suggest that anyone who has discounted the Enterprise Library in the past take another look. I first used the Enterprise Library in one of it's first interations. It's grown and matured and can make some common, time consuming development activities go away.

SCSF Guidance Recipes Not Available

Anthony Trudeau — Thu, 23 Apr 2009 22:26:09 GMT

I ran into a problem with a Smart Client Software Factory (SCSF) solution that I'm working on. I created my modules and then attempted to create my views within those modules. I used the "Add View (with presenter)" recipe; however, the resulting dialog would not let me select my module projects.

The requirements for running the recipe are that you need to reference the main composite application libraries namely Microsoft.Practices.CompositeUI and Microsoft.Practices.ObjectBuilder and you need a reference to your Infrastructure.Interface project. All of these requirements were in place.

I came upon a comment buried on page that laid out a very complex solution that involved rebuilding the guidance package from source code. The comment laid out an alternate way to work around the problem; although in of itself it isn't a great solution.

Here are the steps:

Open the Properties for your Infrastructure.Interface project
Remove the solution name from the assembly name (the assembly name should then be Infrastructure.Interface)
Save and rebuild the solution
Run all of the recipes you need
Restore the solution name

Like I said this isn't a great solution, but I don't have time to mess with rebuilding the guidance package and everything else that might entail.

Using an UltraExplorerBarGroup as a UIExtensionSite

Anthony Trudeau — Tue, 14 Apr 2009 22:33:22 GMT

The Infragistics NetAdvantage control suite provides good support for the composite application block (part of the smart client software factory). However, I ran into the difficulty today when I wanted to extend an existing group in an UltraExplorerBar instance.

I'm using an UltraExplorerBarWorkspace in my ShellLayoutView. At the start, it contains only one group with the text "Properties" and the key "PropertyGroup". I have the need for modules to add their own groups and to add items to the "PropertyGroup". The former is straightforward and just requires you to create a group in the module and add it dynamically to the extension site. The latter, however, isn't clear at all.

I started out by defining my extension site to use the UltraExplorerBarGroup with the key "PropertyGroup". The site was registered in my view's presenter class and then referenced in the module's controller class using the following code (simplified for brevity):

UIExtensionSite propertyGroup =

WorkItem.UIExtensionSites[UIExtensionSiteNames.PropertyGroup];

propertyGroup.Add(ViewElementFactory.CreateCoilPropertiesItem());

In this code, CreateCoilPropertiesItem returns a new UltraExplorerBarItem. Unfortunately, the code doesn't work. You get an exception of type ModuleLoadException with the text:

Failed to load module from assembly ... Error was: UI element must be a Infragistics.Win.UltraWinExplorerBar.UltraExplorerBarGroup.

The UltraExplorerBarGroup can contain other UltraExplorerBarGroup instances as well as UltraExplorerBarItem instances. Therefore, I tried it again but this time when I registered my UI extension site I registered the Items collection of the UltraExplorerBarGroup like the following:

// property within the ShellLayoutView
internal UltraExplorerBarItemsCollection PropertyGroup

{

   get

   {

       return _leftWorkspace.Groups["PropertyGroup"].Items;

   }

}

// code within the view's presenter

WorkItem.UIExtensionSites.RegisterSite(UIExtensionSiteNames.PropertyGroup, View.PropertyGroup);

That did the trick. And although it wasn't clear it wasn't hard to figure out.

Simple explanation for co-variance and contra-variance

Anthony Trudeau — Mon, 13 Apr 2009 19:32:49 GMT

Co-variance and contra-variance have always been two terms for me that made me pause. Neither are hard to understand and we often use what they mean instinctively in object-oriented programming. However, before today if you were to ask me what they were I would have to give you an example. For some reason, a clear, concise definition escaped me.

Then today I read a blog post on C# v4.0 on the Intel website that summed it up in one of those "ah ha" and "duh" moments.

Co-variance is when you treat something more derived as something less derived
Contra-variance is when you treat something less derived as something more derived

And the examples (not designed to model anything real) are easy:

// co-variance
private void DoSomething(object[] objects) { ... }

string[] myStrings = new string[] { "a", "b", ... };
DoSomething(myStrings);

// contra-variance
private void DoSomething(MyConcreteObjectA a) { ... }

private void DoSomething(MyConcreteObjectB b) { ... }

private MyObjectBase CreateObject() { ... }

MyObjectBase newObject = CreateObject();
DoSomething(newObject);

Learning Ruby: First Thoughts

Anthony Trudeau — Fri, 20 Mar 2009 21:01:57 GMT

I posted a few weeks ago about not being able to find time to learn a new language. Well this week I got a beginners book on Ruby for my birthday; and I've decided to make a concerted effort to find the time -- even if it's just a bit of time.

Ruby is an interesting language. It bills itself as being expressive and so far I have to agree. Although there are some notable exceptions. For example, I don't think it's very clear that the following line of Ruby code changes the elements in the array for each element.

[1, 2, 3, 4].collect { |element| element * 2 }

On the other hand I really like how the regular expressions are integrated within the string handling -- C# and other .NET languages use the RegEx class. For example, in Ruby I can replace a call to a static Match method on the RegEx class with the following (it's definitely more expressive).

puts "String has vowels" if mystring.match(/[aeiou]/)

Typing is probably my biggest concern. I'm used to strongly-typed languages. When I was programming Visual Basic I always loathed the Variant, and for that matter I'm a little squeemish on using the Object type (I heart you Generics). Ruby is not strongly-typed, but it seems to be dynamically typed rather than weakly typed (what I've read so far hasn't elaborated on it). The following two code examples illustrate why Ruby isn't weakly typed.

'VB for Applications example
Dim x(2) As Variant

x(0) = 1
x(1) = 2
x(2) = 3

If x(2) = 3 Then Debug.Print "x(2) = 3"
If x(2) = "3" Then Debug.Print "x(2) = '3'"

The example in VB for Applications will display both messages, because the integer in the array is coerced into a string for the comparison.

#Ruby example
x = [1, 2, 3]

puts x.include?(3)
puts x.include?("3")

This example will display true and false for each line respectively. There doesn't seem to be any evil type coercion.

At the fear of looking like a complainer I have to say my first impression of Ruby is with the tools they provide. Specifically, fxri which is first day program simple looking. I like that you get some documentation there (since there is nothing like Intellisense anywhere), but why does it have to load every single topic into the pane; and why does the pane indicate that there are 13,438 of 13,437 entries...

Overall, I'm enjoying the experience. I'm not sold on the language and at this point I'm not sure what it brings to the table for me as a C# developer; but I've only been looking at it for a few days so the jury is out.

How do you stay fresh?

Anthony Trudeau — Tue, 10 Mar 2009 15:25:12 GMT

This isn't a post on personal hygiene, but of skills. My responsibilities at work keep me so busy that I barely have time to read an article let alone learn a new language or technology. I have a sizable library of books and I read through them whenever I get a chance, but often don't have the time to really go indepth and practice on the technology. I suppose it's better than nothing.

Now if I were a bachelor and didn't have my daughter (wouldn't trade her for anything even programming) it wouldn't be a problem. My off-roading hobby is a weekend activity when I get a chance to do it, so on most evenings I would have time to cozy up with a book on the latest and greatest technology, read some articles or blog posts, and possibly even learn a new language. That isn't an option though. So I'm curious, do any of y'all have tips for keeping your skills fresh?

Simple Caching

Anthony Trudeau — Tue, 24 Feb 2009 17:08:14 GMT

In a current project I had a need for a lightweight caching mechanism. My needs were driven by a desire to minimize file access. The file in question would likely not be too long; however, I couldn't guarantee that. Therefore, a caching framework such as provided by the Enterprise Library was just too much. This post talks about what I put together. The following are the only imports necessary.

using System;
using System.Collections.Generic;

My requirements are simple enough. I want to be able to add an object to a cache based on a string name. I want to be able to retrieve that same object, and I want to be able to determine (without raising an exception) if the cache contains an object. And I want to be able to clear the cache. I will clear the cache if I determine that my file has changed -- thus likely invalidating data within the cache. Of course I want it strongly typed and to support any type of object (for future use) and finally it needs to be thread safe. Here's the pseudo-code interface:

void Add(string key, T newObject)
T GetObject(string key)
void Clear()
bool IsCached(string key)

All of these requirements are simple to implement. But, I decided that I would add support for one more thing -- ICloneable. The support wouldn't be an interface implementation, but rather supporting the caching of objects that implement the interface. This can be important, because the objects I deal with are mutable and I don't want external code to corrupt my object state.

Here's the completed class that does everything I need.

 
internalclassObjectCache<T>
{
    private Dictionary<string, T> _cache = new Dictionary<string, T>();
    private object _syncObject = new object();
 
 
public ObjectCache()
    {
    }
 
    public void Add(string key, T newObject)
    {
        if (string.IsNullOrEmpty(key))
            throw new ArgumentNullException("key");
        if (newObject == null)
            throw new ArgumentNullException("newObject");
 
        /* create a clone copy for the cache if the object implements

         * ICloneable; this provides an immutable collection of cached objects */
        T cacheObject = (newObject is ICloneable 

                        ? (T)((ICloneable)newObject).Clone() : newObject);
 
        lock (_syncObject)
            _cache.Add(key, cacheObject);
    }
 
 
public T GetObject(string key)
    {
        T cacheObject;
 
        lock (_syncObject)
            cacheObject = _cache[key];
 
        /* return a copy of the cached object to enforce the
         * immutable collection */
        return (cacheObject is ICloneable 

               ? (T)((ICloneable)cacheObject).Clone() : cacheObject);
    }
 
 
publicvoid Clear()
    {
        lock (_syncObject)
           _cache.Clear();
    }
 
 
publicbool IsCached(string key)
    {
        lock (_syncObject)
            return _cache.ContainsKey(key);
    }
}

Unit testing for serialization

Anthony Trudeau — Sun, 04 Jan 2009 22:54:33 GMT

I'm created a simple utility class for unit testing serialization for my first post of the year. I originally created the class to test data contract serialization, but I extended it for IFormatter based serializers for another class I needed to test. I hope it proves useful.

You'll need the following using statements:

using System;
using System.IO;
using System.Runtime.Serialization;

The following utility class will help you with unit testing serialization for your data contracts and serialization using a standard IFormatter:

internal static class SerializationHelper
{
    public static string SerializeDataContract<T>(T testObject) where T: class
    {
        string fileName = Path.GetTempFileName();
 
        using (FileStream stream = new FileStream(fileName, FileMode.OpenOrCreate))
        {
            DataContractSerializer serializer = 

                new DataContractSerializer(typeof(T));
            serializer.WriteObject(stream, testObject);
        }
 
        return fileName;
    }
 
    public static string SerializeObject<TObject, TFormatter>(TObject testObject)
        where TObject : class
        where TFormatter : IFormatter
    {
        string fileName = Path.GetTempFileName();
 
        using (FileStream stream = new FileStream(fileName, FileMode.OpenOrCreate))
        {
            IFormatter serializer = Activator.CreateInstance<TFormatter>();
            serializer.Serialize(stream, testObject);
        }
 
        return fileName;
    }
 
    public static T DeserializeDataContract<T>(string fileName) where T : class
    {
        using (FileStream stream = new FileStream(fileName, FileMode.Open))
        {
            DataContractSerializer serializer = 

                new DataContractSerializer(typeof(T));
            return (serializer.ReadObject(stream) as T);
        }
    }
 
    public static TObject DeserializeObject<TObject, TFormatter>(string fileName)
        where TObject : class
        where TFormatter : IFormatter
    {
        using (FileStream stream = new FileStream(fileName, FileMode.Open))
        {
            IFormatter serializer = Activator.CreateInstance<TFormatter>();
            return (serializer.Deserialize(stream) as TObject);
        }
    }
}

The following is a sample of how you can use the utility class to test a data contract based class (source and target are both objects of the same data contract type):

string serializedFile = SerializationHelper.SerializeDataContract(source);
target = SerializationHelper
    .DeserializeDataContract<WorkflowRequest>(serializedFile);