What would you change about C# if you could? [closed]

Question

With nearly 60 answers to this question it's highly likely that your answer has already been posted. Please don't post an answer unless you have something new to say

Assume that your objectives are the same as for C#. I don't want an answer like "I'd write Python instead". I'm only interested in changes in the language itself - not in the standard library. Perhaps this would be interesting to discuss, but as it is shared between many languages it would be better to discuss this in another question instead.

Please post a single idea per answer; if you want to post several ideas, post several separate answers. Thanks!

Answer 1

I want to be able to have lambda expressions in custom attributes. For example...

[SomeAttribute(p => some_code(p))]
public string SomeField;

For reasonable flexibility, custom attributes should be able to be generic, so that the lambda expression can be properly typed:

[SomeAttribute<string>(str => some_code(str))]
public string SomeField;

This should be pretty simple to implement in the CLR and the C# compiler, too. Just turn the lambda expression into a static method on a special compiler-generated static type that contains all these methods for all those lambda expressions in custom attributes. Then compile the custom attribute data to one that contains the metadata token for that method. The CLR would recognise that the parameter is of a delegate type and automatically turn the metadata token into a delegate by calling Delegate.CreateDelegate() when the custom attribute is requested.

Answer 2

Having previously worked in C++ before C#, I really miss templates. Generics are close, but you can't specify non-types as a generic parameter. C++ template parameters allow typenames and primitives (int, enum, etc.). C++ templates also allow defining specializations. This allows for a wide variety of compile-time specialization. This is entirely useful when portability of generics is not a requirement.

Answer 3

Provide a macro system similar to Python's decorators, or maybe just make attributes more powerful. Using dynamic proxies or IL rewriting for simple AOP features like tracing or transactions is just overkill.

Answer 4

I'd change the name - C# - Google ignores that # character when you search for language-related things so you get unsolicited results for C/C++ stuff.

Answer 5

"raise" keyword for events

I'm tired of writing small methods just to trigger events thread-safely.

Answer 6

I'd like to see the ability to pass properties by reference. Like

int.TryParse(some_numeric_string, out MyProperty)

It's already been done in VB, so it's definitely possible.

Answer 7

Smarter if statements ie:

object foo = GetAnObject();
if(foo is string) 
    Console.WriteLine(foo.ToUpper());//foo is typed as string
else if(foo is int)
    Console.WriteLine(foo + 2);//foo is int

Answer 8

Some syntactic sugar for the long-winded type-check-and-cast:

if (obj is MyType)
{
    var o = (MyType) obj;
    <use o>

e.g.

if ((var o = obj as MyType) != null)
{
    <use o>

or something a bit less ugly and more thought-through.

Better still, perhaps some special support for polymorphic extension methods. Code like the above is often the result of writing an extension method that would really have been a virtual method with overrides had it been implemented in the original class.

Answer 9

Sometimes I miss friend class and functions. They are quite powerful in some scenarios.
Apart from that they can also help in unit testing private methods of a class.

Answer 10

Mine's a fairly simple one - i'd have preferred it if properties and methods were virtual by default.

Answer 11

I would add Duck-Typing. Think of it as implicit interfaces. If an object implements the set of methods that compose an interface it is considered to implement that interface, even if the class does not explicitly name it.

Answer 12

i'd have preferred if LINQ to SQL is compatible with the others database types (Oracle,MySQL,PostgreSQL...)

Answer 13

I would make the language and also the common language runtime have yet more static typing with; kinds, monads and type-classes. It would allow all the generic constraints suggested above, on both methods and properties.

This discussion on channel9 shines some light on why this would be great in a multi-core world. Principally it would allow you to encapsulate state changes into the type system, allowing for greater library optimisation and improvements.

Answer 14

Eliminate "ref" and "out" parameters

Surely there has to be a better way, I cringe every time I has to use a BCL method with ref parameters (like TryGet)

Answer 15

1. Improved support for defining local helper functions. Anonymous methods bring disproportionate runtime + code-size overhead, can't be generic, and recursive anonymous methods are very clumsy.

2. Support for a generic type parameter constraint specifying constructor signature(s).

3. Support for a generic type parameter constraint specifying method/property signature(s).

4. Nullability should be handled consistently across reference and value types and disabled by default. "nullable string" and "string" should not be represented by the same type.

5. A module system like SML's. The closest things C# has to approximating this are generics + interfaces and neither can unify multiple implementations of a set of related types and functions.

6. Allow a default value to be specified for automatically generated property getters/setters

7. Convenience features stolen from functional languages: pattern matching expression, let..in expression, etc.

8. Extension properties, extension constructors.

Answer 16

Remove static entirely, and replace with pure for methods and threadlocal for fields. Any data to be shared between threads should be passed as immutable data.

Answer 17

One thing that I miss from my C++ background is const correctness. i.e. do not allow constant objects to be changed.

Answer 18

Case-sensitivity.

I'd make C# autocorrect case like VB .NET does, so that whether you type in all caps or all lower-case or a mixture, your code comes out in the correct case once you move off the line.

It vexes me greatly when I type the name of a class, but I don't happen to capitalize it, and C# pretends it has no idea what I'm talking about.

Answer 19

Get rid of the var keyword.

Allow fall-through cases in switch() without having to jump through hoops.

I'd love a version that's less entangled with the framework that could be used to generate native code. C# is a lot like Delphi (thanks, Anders!) which used the Borland C++ compiler back-end. There's no reason C# couldn't do the same with MSVC.

Support for inline assembly. Just because I'm crazy like that.

A neat trick would be to build something that compiles C# into C++. You'd get to keep succinct syntax, a great object model, good exception handling, etc. I know there's no 1:1 correspondence between the two languages on many points, but it's possible. Yeah, I'll get right on that (not).

Answer 20

Enums that actually represent a contiguous set of numbers should be permitted for array indexes. Sure, you can easily cast them but that doesn't let the compiler protect you from mistakes. This would also apply to bools.

Answer 21

I want indexers not to limit modification. like this:

...
// MyList<T>
public this[int index]
{
get{/*do something to return value*/}
set{/*do something to set value*/}
}
...

so:

MyList<MyPersonClass> lst = new MyList<MyPersonClass>();
lst.Add(SomePeople);
lst.Add(SomeOtherPeople);
lst[0].name = "Fred";    // error
lst[1].last = "McKenny"; // error

Answer 22

I would like to be able to add white space to values inside of enums. I know this seems minor but it actually comes up a lot.

Answer 23

Not sure if someone put something about automatic casting:

int age = 70;
var foo = "John Lennon would be " + age + " years old";
Console.WriteLine(foo);

//---- output
John Lennon would be 70 years old

Answer 24

First about this, is that I don't like the way this question is posed specifically the requirement of one answer for post, since that is a call for spamming.

So, I would leave all my answers in one post, and let people vote accordingly, and if they want specify the one they like or don't in the comments to this answer.

1. I would go and remove everything that only has one use, since there is probably some other way of doing that without that change;

2. Make the language more stable, so that it don't change as the versions of visual studio or .net change, that would do a lot for the language adoption, since it is what java always had, and java is the language of the seven lifes.

3. Remove lambda expressions, since delegates are more general and do the same.

4. Remove the var keyword, or add the requirement that you either use vars (dynamic types) or static types, since it is a mess to find both of them in the same function!

And thats all, folks...

Answer 25

I'd get rid of the syntax litter like {} and ;. And var (which makes a C# programmer a VB.NET programmer)

Answer 26

I would restrict var to enumerable query results (probably would change the keyword to query at the same time), create a contextual keyword called anon to deal with anonymous types outside of query results, and then make the class name optional on the right side in an initialization statement.

It would cut out utter crap like

var mystring = "lol"; // not permissable, lazy bum
var randomObject = ThisFunctionNameMeansNothing(); // get the freak out

While still cutting down on space produced by generics and long class names

MyRidiculouslyLongClassName<string, int, Foo> myClass = new();