The dynamic keyword does run-time duck typing. I'm surprised they put this in.

This is done using the first one we find of:

• COM IDispatch
• IDynamicMetaObjectProvider
• Reflection

We should probably implement IDynamicMetaObjectProvider in most cases to make things faster? But performance benchmark it first.

Not to be confused with var, which is type inference.

In generics, we can now use the out and in keywords, like Thing<out X>

If we don't specify these, our type is invariant.

The ref keyword (call by reference) is now optional when calling COM methods.

It will magically create a variable and refer to it for you.

There is also a thing called Embedded Interop. This means you don't have to ship so much code when you use COM.

You can put one of these attributes on a string typed method parameter, and default that parameter's value to null:

• CallerMemberName
• CallerFilePath
• CallerLineNumber

When the method is called, the default will be overridden with some magic reflection info.

A useful debugging and tracing tool.

Built on the Task<T> type.

When you declare a method (or lambda), you can mark it with the async keyword.

When you call an async method, you use the await keyword. You can only use this inside a method which is itself declared async.

Await is what actually passes control over. Behind the scenes, it will cleverly sort out a reactor loop, and yield execution whenever it comes to the await keyword.

This is useful for I/O operations, like waiting for a database, a network, or another process. However, you can use the same pattern together with the Task Parallel Library (Java equivalent is Fork/Join) if you actually just want to do some CPU work in parallel.

Useful static methods on the Task class:

Task.WhenAll(tasks)

returns a Task which is complete when all the tasks are complete.

Task.WhenAny(tasks)

returns a Task which is complete when the first task completes.

Task.Delay()

returns a Task which is complete later.

Task.Run(task)

run the Task on another thread.

Overall, using async and await is still going to turn the control flow of your program inside-out.

As of C# 7.1, you can also declare your Main method to be async and have it return a Task.

Added the using static keyword. Not clear if it works with enums — I should check.

You can now put a guard condition on your catch blocks. These are called exception filters.

try {
    Whatever();
} catch (Exception ex) when (MyCondition()) {
    // do some stuff
}

This is useful for debugging, if you have break on uncaught exceptions turned on.

Additionally, you can now throw exceptions as part of an expression (for example, inside a ternary).

When you declare a property, you can now set its initial value. This works even if it's read-only.

The value must be statically computable.

public String Thing {get;} = "Oy oy " + "savaloy!";

Like methods, property getters can now use the lambda => syntax.

There's a new ?. operator, which is like the normal . operator, but with a null check first.

// This long winded way of writing things
var thing = x == null ? x : x.whatever;

// Is the same as this new syntax
var thing2 = x?.whatever;

For method calls, you need to use the Invoke() method.

var thing = x.?MyMethod.?Invoke();

We can do quick string formatting with a new kind of interpolated string literal.

$"String greeting = Hello, {someExpressionToInsert, minCharacters, formatString}!";

There's also now a nameof function. This is actually a compile time thing rather than a real function call, and turns a variable, type or function into a string.

Wrap each key, value pair in some braces.

I could have sworn this existed before?

var thing = new Dictionary<string, int> {
    {"x", 0},
    {"y", 1}
};

C# now has tuples, which are mostly written like in every other language.

You can give the fields of the tuple names by using an association syntax var thing = (x: x, y: y).

As of C# 7.1, these field names are inferred anyway if you write var thing = (x, y).

It also has simple destructuring. To make this work, you type need to implement the Deconstruct method. The parameters you're outputting should be out parameters, obviously.

You can add destructuring to a type you don't control using extension methods.

You can use _ as a discard value when destructuring.

There's now the combination keyword private protected (containing class or derived types which are in the same assembly).

This compares to protected (derived types) and protected internal (classes in same assembly or derived types).

This seems a bit pointless to me actually.

The switch statement has been extended to understand about type and structure.

switch(thing) {
    case null:
        // matched null
        break;
    case 0:
        // matched some other value
        break;
    case int val:
        // matched on a type
        break;
    case string s when s > "hello":
        // matched on a type and condition
        break;
    default:
        // happens last
        break;
}

The is statement has also been extended. It can match on value and type, but doesn't get the extra condition (which you can just put on with && anyway).