Design Considerations: StructureMap Configuration and Plugin Keys

2007-06-27T01:47:00Z

I started playing with StructureMap recently. I am struggling with how to design my code's interaction with StructureMap when it comes to the configuration and use of plugin keys. If you have any insights or experience with this, please let me know! 1. Configuration via StructureMap.config Pros : * Separation of Concerns * My pluggable code doesn't have to know that its going to be used with StructureMap. A big pro! * One Stop Shop * One file to look at to figure out how the application is configured...(read more)

How-To: "Cast" between List's

2007-06-13T18:50:00Z

Problem:
If you've ever tried to cast been list generics, you know that you can't.

Example:
1. You have two classes Shape and Square, where Square inherits from Shape.

2. You have two generic lists, List<Shape> and List<Square>.

3. List<Square> does not inherit from List<Shape>. So you cannot cast List<Square> to a List<Shape>. It seems intuitive that it should be possible, but it isn't.

You can find more information here, in the "Constructed Types" section, subsection "Conversions", of the C# Version 2.0 Specification Document. The important part is as follows:

"No special conversions exist between constructed reference types other than those described in §6. In particular, unlike array types, constructed reference types do not exhibit “covariant” conversions. This means that a type List<B> has no conversion (either implicit or explicit) to List<A> even if B is derived from A. Likewise, no conversion exists from List<B> to List<object>."

and

"The rationale for this is simple: if a conversion to List<A> is permitted, then apparently one can store values of type A into the list. But this would break the invariant that every object in a list of type List<B> is always a value of type B, or else unexpected failures may occur when assigning into collection classes."

Solution:
Since you cannot cast between them, you end up having to create a new list, code a for loop, and add the items from one list to the other list. Not a big deal, but i got tired of writing the for loop. :) So here is the utility method i created to do it for me:

/// <summary> /// This method adds the items in the first list to the second list. /// This method is helpful because even when X inherits from Y, List<X> does not inherit from List<Y>, and so you cannot cast between them, only copy. /// </summary> /// <typeparam name="FROM_TYPE"></typeparam> /// <typeparam name="TO_TYPE"></typeparam> /// <param name="listToCopyFrom"></param> /// <param name="listToCopyTo"></param> /// <returns></returns> public static List<TO_TYPE> AddRange <FROM_TYPE, TO_TYPE>( List<FROM_TYPE> listToCopyFrom, List<TO_TYPE> listToCopyTo ) where FROM_TYPE : TO_TYPE { // assert Assert.IsNotNull(listToCopyFrom, "listToCopyFrom"); Assert.IsNotNull(listToCopyTo, "listToCopyTo"); // loop through the list to copy, and foreach ( FROM_TYPE item in listToCopyFrom ) { // add items to the copy tolist listToCopyTo.Add( item ); } // return the copy to list return listToCopyTo; }

Here is a test i wrote for my method:

/// <summary> /// This method verifies successfully adding items from one List{} to another. /// </summary> [TestMethod] public void AddRange_Valid() { // create a test list List<TestObjectB> testList = new List<TestObjectB>(); // populate it testList.Add( new TestObjectB() ); testList.Add( new TestObjectB() ); testList.Add( new TestObjectB() ); // declare a result list List<TestObjectA> resultList; // test it resultList = ListUtility.AddRange( testList, new List<TestObjectA>() ); // assert that the items in the test list and the result list are the same Assert.AreEqual( testList[0], resultList[0] ); Assert.AreEqual( testList[1], resultList[1] ); Assert.AreEqual( testList[2], resultList[2] ); }

Ok, Ok, I know its basically just a for loop. But I think the use of a generic method is kind of cool, and it makes my code read a lot better when i have to "cast" a whole bunch of List<>'s. If anyone knows of a better way, please let me know!

Lou Haskett

Design Considerations: StructureMap Configuration and Plugin Keys

How-To: "Cast" between List's