Question

I was just dealing with strings, and I find myself annoyed that strings can be nullable. So, I have to have

if((teststring??string.Empty)==string.Empty) 

all over the place. Would string? have been so hard for allowing nullability in the relatively few cases where it is needed (dbs, idiot user inputs, etc.). I also find myself irritated with having to export readonly interfaces in the cases where I want some form of const correctness. So, what C# language construct/decision annoys you?

EDIT: Thanks for the isnullorempty function, I hadn’t seen that before! Still doesn’t lessen my annoyance at it being nullable 😀

Answer 1

Making string a reference type seems entirely reasonable to me.

It’s a shame that one can’t declare a variable/parameter/return type to be non-nullable though – e.g.

// Never returns null public string! Foo() { } 

Code contracts in .NET 4.0 will help with this, I believe – but it’s a bit late to make it pervasive.

A while ago I wrote a blog entry on the mistakes of C#. To summarise that post:

C# 1:

• Lack of separate getter/setter access for properties.
• Lack of generics. Life would have been a lot sweeter with generics from the start.
• Classes not being sealed by default.
• Enums just being named numbers.
• The ‘\x’ character escape sequence.
• Various things about the switch statement 🙂
• Some odd overload resolution rules
• The ‘lock’ keyword, instead of ‘using’ with a lock tocken.

C# 2:

• Lack of partial methods (came in C# 3)
• Lack of generic variance (coming in C# 4)
• The System.Nullable class (not Nullable<T> – that’s fine!)
• InternalsVisibleTo requiring the whole public key for strongly signed assemblies instead of the public key token.

C# 3:

• Lack of support for immutability – lots of changes improved opportunities for mutating types (automatic properties, object and collection initializers) but none of these really work for mutable types
• Extension method discovery