In C#, we have this non-static method on the type string:
"abc".ToUpper()
but for char, we need to use a static method:
char.ToUpper('a')
When introducing c# to beginners, they always expect to be able to write the following:
'a'.ToUpper()
Does anyone have insights as why it was designed like this?
The only thing I can think of is performance but then I would have expected a static ToUpper() for the type string too.
The difference lies in the fact that string is a reference type, and char is a keyword that represents the .Net Framework's Char Structure. When you call Char.ToUpper('a') you are actually using the Char Structure in C#. Structures are Value Types. Value Types are immutable.
Since structs are immutable, methods that act upon the struct itself do not work as expected (see Why are Mutable Structs Evil). Thus static methods are needed. When calling Char.ToUpper(aChar) you are not actually changing aChar, instead, you are creating a new instance of a character that is the uppercase representation of the character you passed in as a parameter and returning it. The example below demonstrates this.
Char aChar = 'a';
Char.ToUpper(aChar);
//aChar still equals 'a'
Char bChar = 'b';
bChar = Char.ToUpper(bChar);
//bChar now equals 'B'
The reason char has other methods that allow you to do things like 'a'.Equals('a'); is because value types and reference types both inherit from Object, which defines those methods (technically, value types are of type System.ValueType, which inherits from System.Object). These methods do not enact any changes to the object itself.
As I'm very curious to see if there's an actual answer to "why do chars not have a .ToUpper() method", I decided to check out the CSharp 5 Language Specification Document, I have found the following:
char is an Integral Type (pg 80), which is a subset of Simple Types. Simple Types themselves are just predefined Struct Types. Struct types are Value Types that "can declare constants, fields, methods, properties, indexers, operators, instance constructors, static constructors, and nested types" (pg 79).
string is a Class Type, which is a Reference Type (pg 85). Class Types define "a data structure that contains data members (constants and fields), function members (methods, properties, events, indexers, operators, instance constructors, destructors and static constructors), and nested types" (pg 84).
At this point, it is obvious that chars can support a .ToUpper() method (which is why the extension method works). However, as the question states, they do not support one. At this point I'm convinced any reasoning as to why this is true is pure speculation (unless you're on the C# team, of course).
Hans Passant mentioned that it is possible to achieve this syntax easily via extension methods. I'll provide the code here in case anyone is deeply attached to using that syntax.
public static class MyExtensionMethods
{
public static char ToUpper( this char c )
{
return char.ToUpper( c );
}
}
Then you can do:
'a'.ToUpper()
(sorry, not enough space in a comment -- I know this isn't a complete answer.)
This seems to be a pattern across all the primitive types; int, double, and bool, for example, also do not have methods (except ToString() variants). So it's not just char -- it's a property of all the primitive types that c# defines.
I would guess (and it is a guess) that any time you access data, you're either directly accessing bits of RAM -- the primitive values like int and char and byte -- or you're accessing a .NET construct like an object or struct. A char is always 2 bytes at a particular memory address. So the framework can treat it like a raw memory location.
If we try to treat the raw RAM as objects, you'll either have to 'box' everything to do any work, or it's just not possible. My guess is that you can't do some core feature like virtual method dispatch on primitives, and that the world of objects and the world of primitives has to be kept separate.
Anyway, hope that advances the conversation on some level...
