Question

I have a large project which was originally written in C#1.1 and is now targeting C#2.0. There are several classes which have methods which take an ArrayList parameter I would like to start to move these to accept List<T> as a parameter, but this can’t be done all at one time, so I need to accept both parameters.

My main reason for the migration is so that List<> objects will be accepted as parameters, but I would also like to take advantage of type safety.

Have considered

1) Creating overloads and duplicating the code.
This has the advantage of allowing me to mark the old style code as obsolete, but obviously duplicating code is bad.

2) Changing the parameter to IEnumerable :
This has the advantage of working with both old and new code, but is not type-safe as it will accept List<T1> where it should be List<T2>

3) Re-writing the methods to take a List<T> parameter and writing a thin wrapper which takes an ArrayList parameter and copies the items to a new List<T> and then calls the main method. This also has the advantage of allowing me to mark the old style code as obsolete. It will have a slight performance/GC hit.

4) Creating three overloads. One private method which take IEnumerable and two public wrapper methods (one for ArrayList and one for List<T>) which just call the private method.
This also has the advantage of allowing me to mark the old style code as obsolete. Not sure whether it has any dis-advantages other than having three methods.

I am leaning towards 4, but am I overlooking anything?

Answer 1

Definitely use a variant of #2, where you shoot for IEnumerable<T> rather than List<T>. For those that need more than IEnumerable<T>, your goal should be IList<T>.

For those methods that can migrate to IEnumerable<T>, you can move them to just IEnumerable for the short term, and in this way avoid needing to maintain two copies of the method. Then, after most of your ArrayLists are gone you can complete the move to IEnumerable<T> with very little effort.