Cast List<int> to List<string> in .NET 2.0

Can you cast a List<int> to List<string> somehow?

I know I could loop through and .ToString() the thing, but a cast would be awesome.

I'm in C# 2.0 (so no LINQ).

.NET 2.0 has the ConvertAll method where you can pass in a converter function:

List<int>    l1 = new List<int>(new int[] { 1, 2, 3 } );
List<string> l2 = l1.ConvertAll<string>(delegate(int i) { return i.ToString(); });

Updated for 2010

List<int> l1 = new List<int>(new int[] { 1,2,3 } );
List<string> l2 = l1.ConvertAll<string>(x => x.ToString());

Is C# 2.0 able to do List<T>.Convert? If so, I think your best guess would be to use that with a delegate:

List<int> list = new List<int>();
list.Add(1);
list.Add(2);
list.Add(3);
list.Convert(delegate (int i) { return i.ToString(); });

Something along those lines.

---

Upvote Glenn's answer, which is probably the correct code ;-)

You can use:

List<int> items = new List<int>(new int[] { 1,2,3 } );
List<string> s = (from i in items select i.ToString()).ToList();

You wouldn't be able to directly cast it as no explicit or implicit cast exists from int to string, it would have to be a method involving .ToString() such as:-

foreach (int i in intList) stringList.Add(i.ToString());

Edit - or as others have pointed out rather brilliantly, use intList.ConvertAll(delegate(int i) { return i.ToString(); });, however clearly you still have to use .ToString() and it's a conversion rather than a cast.

result = listOfInt.Select(i => i.ToString(CultureInfo.InvariantCulture)).ToList()

replace the parameters result and listOfInt to your parameters

Converting from int List to string List can be done in two adittional ways besides the usual ToString(). Choose the one that pleases you more.

var stringlist = intlist.Select(x=>""+x).ToList();

Or also:

var stringlist = intlist.Select(x=>$"{x}").ToList();

And finally the traditional:

var stringlist = intlist.Select(x=>x.ToString()).ToList();

You have to build a new list. The underlying bit representations of List<int> and List<string> are completely incompatible -- on a 64-bit platform, for instance, the individual members aren't even the same size.

It is theoretically possible to treat a List<string> as a List<object> -- this gets you into the exciting worlds of covariance and contravariance, and is not currently supported by C# or VB.NET.