theburningmonk.com

Given a generic class in C# like this one:

public class MyType<T>
{
    public MyType(T value) { }
}

You will need to spec­ify what the type T should be when you call the constructor:

var myObj = new MyType<int>(42);

The com­piler is not able to use type infer­ence to infer the type T to be int.

Now, this is inter­est­ing as type infer­ence is sup­ported by any other generic method, so if you were to cre­ate a fac­tory class for MyType<T> you could indeed make use of type infer­ence like this:

public class MyTypeFactory
{
    public static MyType<T> Create<T>(T value)
    {
        return new MyType<T>(value);
    }
}
...
var myObj = MyTypeFactory.Create(42); // returns MyType<int>

Some argue that it’s not pos­si­ble because of the pos­si­ble pres­ence of other over­loaded con­struc­tors (or for that mat­ter a non-generic ver­sion of MyType), but at the end of the day the con­struc­tor is a method like any other and the cited ambi­gu­ity can also appear with nor­mal generic methods:

public void Foo(short value) {}
public void Foo(int value) {}
public void Foo(long value) {}
public void Foo(double value) {}
public void Foo<T>(T value) {}
…
Foo(42); // which Foo is called? Foo(int) of course!

So amidst all that ambi­gu­ity the com­piler is able to infer the type for the Foo method, so what’s so spe­cial about the con­struc­tor? Am I miss­ing some­thing obvi­ous here?

Luck­ily, as Eric Lip­pert stated in his answer to my ques­tion here, the rea­son the con­struc­tor does not sup­port type infer­ence is a prac­ti­cal one – the ben­e­fit of the fea­ture does not out-weight the cost of its imple­men­ta­tion and it is some way behind other pos­si­ble fea­tures in terms of pri­or­ity. Whilst he did say that this fea­ture is on the list, con­sid­er­ing that the ‘theme’ of the next C# release (5.0) is rumoured to be meta-programming, there’s a good chance we won’t be see­ing type infer­ence in the C# con­struc­tor for some time yet!

Ref­er­ences:

Jon Skeet’s Brain­teasers + Answers

Stack­Over­flow ques­tion – why can’t the C# con­struc­tor infer type

Whilst read­ing through the answers for this ques­tion on Stack­Over­flow, I came across the IsDigit and IsNum­ber meth­ods on the Char class. And look­ing at the Char class in more detail there are many more use­ful meth­ods on the Char class which I didn’t realise was there before, such as:

IsDigit checks if a char­ac­ter is a radix-10 digit, i.e. 0–9.

IsNum­ber checks if a char­ac­ter can be cat­e­go­rized as a num­ber, includ­ing dig­its, char­ac­ters, frac­tions, sub­scripts, cur­rency numer­a­tors, etc.

Get­Nu­mer­ic­Value con­verts a char­ac­ter to a double.

GetU­ni­code­Cat­e­gory cat­e­go­rizes a char­ac­ter into a group iden­ti­fied by one of the Uni­code­Cat­e­gory enum. This is an inter­est­ing method as it allows you to check whether a given char­ac­ter is a cur­rency sym­bol or maths sym­bol for instance:

char.GetUnicodeCategory('+').Dump();  // UnicodeCategory.MathSymbol
char.GetUnicodeCategory('-').Dump();  // UnicodeCategory.DashPunctuation
char.GetUnicodeCategory('{').Dump();  // UnicodeCategory.OpenPunctuation
char.GetUnicodeCategory('$').Dump();  // UnicodeCategory.CurrencySymbol
char.GetUnicodeCategory('}').Dump();  // UnicodeCategory.ClosePunctuation

IsCon­trol checks whether a char­ac­ter is a con­trol character.

IsLet­ter checks whether a char­ac­ter is a uni­code letter.

IsLet­terOrDigit checks whether a char­ac­ter is a let­ter or a dec­i­mal digit.

IsLower and IsUp­per checks whether a char­ac­ter is lower or upper case letter.

IsWhite­Space checks if a char­ac­ter is a white space.

What’s even bet­ter, each of the meth­ods are over­loaded so that you can pass in the char to test or a string and an accom­pa­ny­ing int to spec­ify the posi­tion of the char in the string, e.g. IsDigit(char) and IsDigit(string, int).