constant-interpolated-string.cs

[Obsolete($"Call {nameof(Discard)} instead")]

expression-trees.cs

LambdaExpression parseExpr = (string s) => int.Parse(s); // Expression<Func<string, int>>
Expression parseExpr = (string s) => int.Parse(s);       // Expression<Func<string, int>>

global-using-item-group-include.xml

<ItemGroup>
  <Using Include="System.IO.Pipes" />
</ItemGroup>

global-using-item-group-remove.xml

<ItemGroup>
  <Using Remove="System.Threading.Tasks" />
</ItemGroup>

global-using-property-group.xml

<PropertyGroup>
    <ImplicitUsings>enable</ImplicitUsings>
</PropertyGroup>

global-using.cs

global using System;
global using static System.Console;
global using Env = System.Environment;

lambda-attributes.cs

Func<string, int> parse = [SomeAttribute(1)] (s) => int.Parse(s);
var choose = [SomeAttribute(2)][SomeAttribute(3)] object (bool b) => b ? 1 : "two";

mix-declarations.cs

int x2;
int y2;
(x2, y2) = (0, 1);       // Works in C# 9
(var x, var y) = (0, 1); // Works in C# 9
(x2, var y3) = (0, 1);   // Works in C# 10 onwards

namespace-oneperfile.cs

namespace MyCompany.MyNamespace;
class MyClass // Note: no indentation, no curly brackets
{
   //...
} 

natural-types-csharp10-error.cs

var parse = s => int.Parse(s); // ERROR: Not enough type info in the lambda

natural-types-csharp10.cs

var parse = (string s) => int.Parse(s);

natural-types-csharp9.cs

Func<string, int> parse = (string s) => int.Parse(s);

natural-types-method-groups.cs

Func<int> read = Console.Read;
Action<string> write = Console.Write;

natural-types-method-groups2.cs

var read = Console.Read; // Just one overload; Func<int> inferred
var write = Console.Write; // ERROR: Multiple overloads, can't choose

positional-record-struct.cs

public record struct Person(string FirstName, string LastName);

property-patterns.cs

object obj = new Person
{
    FirstName = "George",
    LastName = "Kosmidis",
    Address = new Address { City = "Munich" }
};

if (obj is Person { Address: { City: "Munich" } })
    Console.WriteLine("Munich");

if (obj is Person { Address.City: "Munich" }) // Extended property pattern
    Console.WriteLine("Munich");

record-struct.cs

public record struct Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

return-types-lambda.cs

var choose = (bool b) => b ? 1 : "two"; // ERROR: Can't infer return type

return-types-lambda2.cs

var choose = object (bool b) => b ? 1 : "two"; // Func<bool, object>

string-create.cs

String.Create(CultureInfo.InvariantCulture, $"The result is {result}");

stringbuilder.cs

var sb = new StringBuilder();
sb.Append($"Hello {args[0]}, how are you?");

struct-constructor.cs

public struct Address
{
    public Address()
    {
        City = "<unknown>";
    }
    public string City { get; init; }
}

struct-constructor2.cs

public struct Address
{
    public string City { get; init; } = "<unknown>";
}

with.cs

var person = person with { LastName = "Kristensen" };