Fear and Loathing

# re: Generic List Converter Snippet

FWIW, I think this will result in copying the elements three times. ;) From listOfObjects to notStronglyTypedList, to a temporary array to the typed list that gets returned. Alternative version:

List<T> Conv...(IList listOfObjects) {

 List<T> items = new List<T>();

 foreach (T obj in listOfObjects) {

   items.Add(obj);

 }

 return items;

}

# re: Generic List Converter Snippet

Can always use AddRange()...

# re: Generic List Converter Snippet

I take it by IList<People> you mean "an IList containing People objects".

# re: Generic List Converter Snippet

A major benefit of Wilco's approach is that you can accept an IEnumerable instead of an IList, which makes it much more generally useful.

# re: Generic List Converter Snippet

Did this come from Billy McCafferty's article on nHibernate?

http://www.codeproject.com/aspnet/NHibernateBestPractices.asp

# re: Generic List Converter Snippet

I also have an alternative which will twice.

List<T> Conv...(IList listOfObjects) {

T[] temp = new T[ listOfObjects.Count ];

listOfObjects.CopyTo( temp, 0 );

return new List<T>( temp );

}

# re: Generic List Converter Snippet

Well, first of all, you API is a bit nasty.  It use this, we'd have to write:

ArrayList myList = new ArrayList(); //...

ListToGenericListConverter<int> conv = new ListToGenericListConverter<int>()

List<int> yourList = conv.ConvertToGenericList(myList);

which seems a bit extreme.

You probably meant to make the method static, inwhich case it become just:

List<int> yourList = ListToGenericListConverter<int>.ConvertToGenericList(myList);

which is still rather cumbersome.

I think out first step in fixing this is to convert it from a generaic class, to a generic method:

public class ListToGenericListConverter

{

  public List<T> ConvertToGenericList<T>(IList listOfObjects)

  {

    /// etc.

  }

}

This would make it now:

List<int> yourList = ListToGenericListConverter.ConvertToGenericList<int>(myList);

which doesn't look much different, but, since the class now is not involved with the method, we can add it to some class of utility function, which presumably, a simplier name:

List<int> yourList = Utils.ConvertToGenericList<int>(myList);

Also, "ConvertToGenericList" should be changed.  "List<T>" is a generic list.  For that matter, "ArrayList" is a "generic list". "List<int>" is list of a specific type (which just happened to be created using a generic class), and it's important here because it is a specific list.

Now, let's talk implementation.  I see two problems here --- The three copies (which others have mentioned), and the fact that the use must explicitly state the type of the conversion.   You try at fixing them:

static void Convert<T>(ICollection src, out List<T> dest)

{

dest = new List<T>(src.Count);

foreach(T item in src)

{

dest.Add(item);

}

}

static void Convert<T>(IEnumerable src, out List<T> dest)

{

dest = new List<T>();

foreach(T item in src)

{

dest.Add(item);

}

}

They would be used thusly:

ArrayList al = new ArrayList();

al.Add(2);

al.Add(4);

al.Add(3);

al.Add(1);

List<int> il;

Utils.Convert(al, out il);

Initially, I wasn't sure if I wanted to go with the ICollection version (which is more effiecent) or the IEnumerable version (which is more usable).  Then I realized I didn't have to choose.  The compiler considers them distinct, and will choose whichever one is a better fit.

# re: Generic List Converter Snippet

I like how you post a useful snippet and James has to get up on his high-horse so he can talk down to you like hes a bearded great white wizard and you're a repulsive slug struggling with a 3rd grade math assigment.

# In search for the fastest IList to IList<T> conversion

I was yet again busy with a generic data layer. I like type safety as it provides compile time safety