It would be very convenient if you could declaratively inherit documentation from a parent interface/base class so that you don't need to keep documentation updates in sync in multiple places.

Something along the lines of /// <inherit source="FirstParent" restrict="Project" /> type of tag where the source is an enumeration saying how high up to go until it finds documentation (parent/first parent with documentation, abstract class, interface, etc.) and restrict being an enumeration to restrict it to a project/solution/referenced library/bcl.

Typically I would only use this for documentation inheritance between a class and it's interface, but they may not necessarily be in the same project (they will be in the same solution).

/// <summary>
/// Worker interface
/// </summary>
public interface IWorker
{
/// <summary>
/// Do some work
/// </summary>
void DoWork();
}

/// <summary>
/// A Real worker!
/// </summary>
public class RealWorker : IWorker
{
/// <inherit source="Parent" restrict="Project" />
public void DoWork() { ... }
}

Currently we have interfaces, which are the only way to port code around and reuse it. However, I'd like to see something more like what Go has, where any object which, at compile time, can be verified to support all methods/properties required by the target protocol, the assignment will be allowed. This would be enable much more composable and expressive usage of anonymous types, in particular. Consider:

public protocol Prot
{
int Func1(int x, int y);
string Func2();
string Prop;
}

and then these methods (could be in different classes):

void DoSomething(Prot p) { ... }
string SomeString() { ... }

Then this method can be called even with an anonymous type, like this:

// x is an instance of the class which defines the SomeString method from above
var anon = new { Func1: (x, y) => x + y, Func2: x.SomeString, Prop: "hello world" };
DoSomething(anon);

This is a specific use case, but illustrates the increased portability of code beyond what is currently possible with interfaces.

Note: as with anonymous types today, properties of prototypes would have to be read-only.

double mydouble, dblA, dblFrom, dblTo;
<code>
switch(mydouble)
{
....case(dblA, dblFrom .. dblTo)
....{
........Console.WriteLine("variable or variable range");
....}
....case(5.7 >< 8.3)
....{
........Console.WriteLine("between");
....}
....default
....{
........Console.WriteLine("default");
....}
}

- there is no fall through of course but there are branches
- each branch of a block{} or a single statement (like the if)
- variables can be used (not only constants)
- range and between operators can be used (frequent testing)
- comfortable, comma-separated expression lists for the cases
- the new syntax fits into the C# style (see try-catch, if)
- do not need new C# keyword
- the old syntax and the new syntax can not be mixed

Many times when using classes, I find myself wishing I could set read-only properties in the object initializer block rather than being forced to pass them to the constructor:

var myObj = new MyObj
{
ReadonlyProperty1 = "hello",
ReadonlyProperty2 = "world"
}

This is currently not possible, since you can only make the setter public or mostly inaccessible from whatever scope you're in (even protected is fairly limited). Perhaps you can introduce a special scope modifier "init", which allows an otherwise inaccessible property setter to be visible only in the object initializer block:

public class MyObj
{
public ReadonlyPropery1 { get; private init set; }
public ReadonlyProperty2 { get; protected init set; }
}

The above makes the two otherwise inaccessible setters visible only in the object initialization block.

When writing algorithms, I try to stay as close to the mathematical definition of an equation as possible.

This mostly requires discipline on my part to define, and use, types and operator overloading, not succumb to premature optimization etc. etc.

I realized the other day that C# code is stored in UTF-8, which has a lot of mathematical symbols.

I would like to be able to write:

var sₖ = new Matrix();

var sₖᵀ = Matrix.Transpose(sₖ);

var c₁= sₖᵀ * sₖ;

Interestingly enough, C# already allows you to use non-ascii letters (like European accented characters) in identifiers. This is of course to allow programmers whose primary language is not English to write variables with names that are meaningful to them.

I would like to see this policy extended to support those programmers who want to accurately depict expressions in the "language" of mathematics.

Please add dictionary initializer syntax similar to Python, JavaScript and other dynamic languages have. It would be very useful to create some set of properties.
The way MvcContrib project uses anonymous types is an example of a good use for such syntax. While anonymous types and Reflection is a workaround it is very slow compared to initializing dictionary (~10 times slower). The types of keys and values could be determined by the common ancestors (same as in array initializer syntax) or the created dictionary mat be non-generic (e.g. Hashtable).

Example:
IDictionary<string, object> d = new[ , ] {{"Hello", "World"}, {"Count", 2}, {"Type", typeof(int)}};