So my first gripe about C# is one that I ran into by mistake. I was playing around with some AJAX components, and one called for a web service method that returned an array of strings. I wanted to populate that array of strings with a database call. That seems simple enough, right?

Wrong. It took me several hours to figure out what object types were being returned by methods, what object types I wanted to be returned by methods, and what in G-d’s name I needed to do to get the values from the one type to the other.

Eventually I managed to extract the strings I wanted from the jumble of overlapping database classes and methods (why a framework needs that many ways to get data from a database, I don’t know). Now all I had to do was stuff those strings into an array. That seems simple enough, right?

Wrong. C# doesn’t allow for dynamically sized arrays. OK, well, I just need to find the size of the data set and make the array that size. Except I can’t just get the size of the data set. Why? Because for some reason the database select method I stumbled on returns an IEnumerable, which for some reason doesn’t keep a count of its members. Because why would you ever need to know how many results you get from a query without wanting to first loop over those results?

So putting that data directly into an array would mean looping over the data set not once, but twice. The first time around I’d only be incrementing a counter. Then I could initialize my array to the correct size. Then I could loop over the data set again and actually populate the array. Seriously, Microsoft?

I couldn’t bring myself to do that, so I did some quick searching and found the ArrayList class. It was exactly what I wanted, and it had a seemingly straightforward method to convert its contents into an array. Hooray.

So I try something like the following code:

public string[] someFunction(string someArg) {
	ArrayList aList = new ArrayList();
	// Populate aList with string objects
	return aList.ToArray();
}

No good. It throws an error saying I cannot implicitly convert an array of objects into an array of strings. I think it’s odd that this is an issue given that the objects are strings, but I try the following:

public string[] someFunction(string someArg) {
	ArrayList aList = new ArrayList();
	// Populate aList with string objects
	return (string[]) aList.ToArray();
}

This doesn’t give me any errors, but it doesn’t give me any data, either. Fine. If that’s how you want to play it, C#, that’s how we’ll play it. So I try this:

public string[] someFunction(string someArg) {
	ArrayList aList = new ArrayList();
	// Populate aList with string objects
	return aList.ToArray(typeof(string));
}

Suddenly the angry red squiggly is back, with the error that I cannot implicitly convert type ‘System.Array’ to type ‘string[]‘. It assures me that an explicit conversion exists, and asks me if I’m missing a cast. You’re joking, right? Right?

As it turns out, what I actually needed was:

public string[] someFunction(string someArg) {
	ArrayList aList = new ArrayList();
	// Populate aList with string objects
	return (string[]) aList.ToArray(typeof(string));
}

Because it’s not enough to convert a list of string objects to an array of string objects. You also need to convert the individual string objects to string objects. And then you also need to convert the array of string objects to an array of string objects. Did you notice that only one of those steps actually changed the type of anything? I certainly did.

Maybe this wouldn’t have been such an issue if I hadn’t been using a pre-built component that demanded an actual array of strings. Perhaps “old school” arrays are used infrequently in the rest of C# land. But the fact remains that a language should not require you to cast a type into itself. Repeatedly.

The mind boggles.