I do not primarily program in C#, and I have done decent amount of Java. As far as languages are concerned, I find C# 4.0 a superior language to Java 6.
I took a look at both Scala and F# - F# seemed simpler and more concise to me.
One of my grudges is absence of a standard package manager for .net - Java has maven, ruby has gem, python has pip, C# has ?
Edit* Just wanted to clarify it is not specifically for C# but the .NET platform in general.
I love visual studio and C#. But NuGet's pretty pants, it just feels like you're being treated like a child.
To me this just smacks of the overkill of the asp.net membership system to me. Vastly overcomplicated to do a simple job. Maybe I'm just getting cynical in my old age and it's time to switch to linux. There's lots of little things that bug me in .Net though so it's probably just one of my pet peeves. For example I've always detested the obsession asp.net has with ~ that for the most part is totally and utterly pointless.
With a lot of things MS seem to approach the problem with the most complicated use case in mind rather than the simplest.
Sounds much like a matter of taste then, though. I much prefer clicking a button over typing a command (f.ex. tortoisegit over git, explorer over bash mv/cp/etc).
I spent a lot of time in the last week implementing an internal DSL in Java which in turn got me meditating on Scala.
I'm not sure that the increased fluency of Scala syntax is really a win for internal DSLs. My fear is that the fluent syntax depends a lot on fine details of the language; you could make some beautiful examples for the DSL's documentation, but take one step away from that and the user of the DSL has to deeply understand Scala's corner cases.
One thing that could be good about Scala, like ML derivatives is pattern matching.
Somebody with a lot of OO experience who's used to building things in an OO way might have a negative impression of pattern matching for polymorphism as opposed to conventional polymorphism. However, if you're building out an AST and you might want to process it in different ways, the pattern matching paradigm could be much better. For instance, if you've got something like a C# expression tree, you might want to 'interpret' it in the obvious way, or compile it to Java bytecodes, or compile it to a SQL query string, or do any of a number of different things. Pattern matching would provide a lovely way to do this.
Edit: this is a joke
I used Scala on a project a year or so ago. I needed/wanted to target the JVM. However, after looking at Java the language, I realized how far it was behind C# now. (I hadn't used Java in several years after going to work for a Microsoft shop).
Scala was fairly easy to learn, the new features of C# really coalesced nicely with the Scala language, so I didn't feel like I had to learn much.
There are some nice features of Scala (var/val immutability, etc) that would be nice to see in C#.
I think Scala adoption in the .NET community may be hampered by 1) continual improvements in the c# language and 2) the F# language.
The F# language in particular because it has full IDE support.
The Achilles heel of Scala was lack of really good IDE support. Coming from C#/Visual Studio, working with Netbeans and the Scala plugin was somewhat frustrating...it wasn't quite ready for prime time. (Considering it was the work of one person, it worked very well but had a few issues).
IntelliJ pretty much rocks, Eclipse is done by the Scala team itself (no idea about Netbeans, though). While Scala IDEs haven't reached the level of maturity or the wealth of features of Java IDEs, they have useful features even Java IDEs lack.
I guess the .NET port is mainly for people wanting to keep writing Scala regardless if they are targeting the JVM, the CLR, browsers with JavaScript/GWT or the LLVM.
Additionally, most Java developers want to stay on the JVM, because it guarantees high performance, stability and maturity and has a wealth of well-known third party libraries.
C# has non-broken generics, (contra/co)variance, closures, method pointers, expression trees, type inference, value types (can implement complex numbers that take up just 8 bytes!) and many other little features that show that the language designers have some respect for programmers.
If anything, C# is the language that Java refugees are looking for, not Scala.