OK first up, No one language/platform is ever going to be universally superior.
- Specialization will always provide a better use case in certain areas but general purpose languages will be applicable to more domains.
- Multi-paradigm languages will suffer from complex boundary cases between paradigms e.g.
- Type inference in any functional language that also allows OOP when presented with sub classes
- The grammar of C++ is astonishingly complex, This has a direct effect on the abilities of its tool chain.
- The complexities of co/contra variance coupled with generics in c# is very hard to understand.
Older languages will have existing code bases that work, this is both positive (experience, well tested, extensive supporting literature) but also a negative (the resulting inertia against change, multiple different ways to do things leading to confusion for new entrants).
The selection/use of both languages and platforms is, as are most things, a balancing of the pros and cons.
In the following lists Delphi has some of the same pros and cons, but differs on many too.
Potential Negatives of .Net (if they are not an issue to you they aren't negatives)
- Yes, you need the runtime deployed (and installed), and it's big.
- If you wanted a language with multiple inheritance you're not going to get it
- The BCL collections library has some serious flaws
- Not widely supported outside the MS universe (mono is great but it lags the official implementation significantly)
- Potential patent/copyright encumbrance
- Jitted (ignoring ngen) start up time is always going to be slower and more memory will be needed.
There are more but these are the highlights.
Potential Positives (again if they don't matter to you)
- A universal GC, no reference counting that prevents certain data structures being usable, I know of no widely used Functional language without GC, I can't think of significant language of the last 10 years without at least optional GC. If you believe this is not a big deal you would appear to be in a minority.
- A large BCL (some parts not so good as others but it's very broad)
- Vast numbers of languages (and a surprising number of paradigms) can be used and interact with each other (I use c#, f#, C++/CLI within one wider application using each where it makes most sense but able to easily use aspects of one from another).
- Full featured introspection combined with declarative programming support. A wide variety of frameworks become much simpler and easy to use in this manner.
- Jitted - alterations in underlying CPU architecture can be largely transparent, sophisticated runtime optimizations not available to pre-compiled languages are possible (java is doing rather better on this currently)
- memory access safety
- Fusion dll loading and the GAC for system dlls
Likewise specifically for c#
Con:
- Syntax based on C underpinnings
- (pre 4.0) late binding solely via inheritance
- More verbose than some imperative languages
- poor handling of complex embedded literals (regexes/xml/multi line strings)
- variable capture within closures can be confusing
- nested generators are both cumbersome and perform appallingly
Pro:
- Syntax based on C underpinnings
- Much functional support through lambdas
- Expressions allowing compile time validation of non code areas such as Linq to SQL
- Strongly typed but with some Type inference to make this easier
- if you really need to unsafe is there for you
- interaction with existing C++ ABI code via P/Invoke is both simple and clear.
- multicast event model built in.
- light weight runtime code generation
The C underpinnings really is a pro and con. It is understandable by a vast number of programmers (compared to pascal based style) but has a certain amount of cruft (switch statements being a clear example).
Strong/Weak/Static/Dynamic type systems are a polarising debate but it is certainly not contentious to say that, where the type system is more constraining it should strive to not require excessive verbosity as a result, c# is certainly better than many in that regard.
For many internal Line of Business applications a vast number of the .Net platform Cons are absolutely immaterial (controlled deployment being a common and well solved problem within corporations).
As such using .Net (and this does largely mean c#, sorry VB.Net guys) is a pretty obvious choice for new development within a windows architecture.