Why is C# Case Sensitive? [closed]

Answer 1

I think the fact that case can convey information is a very good reason. For example, by convention, class names, public methods and properties start with an uppercase letter by convention. And conversely, fields and local variables start with a lowercase letter.

After using the language for years, I've come to really enjoy this, code is much easier to read when you can read information simply from the casing of the words.

And that's why people do this sometimes, and it can make sense:

Foo foo = new Foo();

I do that all the time, it's very useful. If you think about it in a more useful situation like this:

Image image = Image.LoadFrom(path);

It just makes sense sometimes to call the instance the same thing as the class name, and the only way to tell them apart is the casing. In C++ the case-sensitivity becomes even more useful, but that's another story. I can elaborate if you're interested.

Answer 2

Probably copied from C, C++, Java, etc. or may be kept the same on purpose so that its similar to what other langauges have.

Answer 3

Consider the variable names in the following pseudocode:

class Foo extends Object { ... }
...
foo = new Foo();

Having case sensitivity allows conventions which use case to separate class names and instances; such conventions are not at all uncommon in the development world.

Answer 4

You are looking at this in a very limited way - from your point of view. Language designers must take into account a whole other set of considerations: cultural reasons, compatibility with other languages, common coding practices etc

All modern languages use case-sensitivity: which ones don't?

As someone who used BASIC for a number of years I got very tired of developers using different cases for the same variable. This sort of thing is very tiresome to look at and encourages sloppy programming. If you can't be bothered to get the case right - what else can't you be bothered to do?

Answer 5

Parsing is also a tiny bit easier for case-sensitive languages. As long as there's no good reason to choose the non-case-sensitive way, why bother?

Answer 6

I assume you'd like to see code like:

SomeField=28;
someField++;
somefield++;
SOMEFIELD++;

compiled as if SomeField in any casing variation is the same variable.

Personally, I think it's a bad idea. It encourages laziness and/or carelessness. Why bother properly casing the thing when it doesn't matter anyway? Well, while we're at it, maybe the compiler should allow misspellings, like SoemField++?