Span<int> numbers = stackalloc int[] { 1, 2, 3, 4, 5 };
Console.WriteLine(                    numbers .CountElements(3));
Console.WriteLine(((ReadOnlySpan<int>)numbers).CountElements(3));

static class SpanExtensions
{
    public static int CountElements<T>(this ReadOnlySpan<T> x, T elementToFind)
    	where T : IEquatable<T>
    {
        int count = 0;
        foreach (var item in x)
        {
            if (item.Equals(elementToFind))
            {
                count++;
            }
        }

        return count;
    }
}

// UserCode.cs
public partial class ViewModel : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

	[NotifyPropertyChanged]
    public partial string UserName { get; set; }
}

// Generated.cs
public partial class ViewModel
{
    private string __generated_userName;

    public partial string UserName
    {
        get => __generated_userName;
        set
        {
            if (value != __generated_userName) {
                __generated_userName = value;
                PropertyChanged?.Invoke(this,
                	new PropertyChangedEventArgs(nameof(UserName)));
            }
        }
    }
}

var p = new Properties
{
    ManualProp = "",
    AutoProp = "",
    AutoInitOnlyProp = "",
    RequiredProp = "",
};

class Properties
{
    private string? ManualPropValue;
    public string? ManualProp
    {
        get => ManualPropValue;
        set => ManualPropValue = value;
    }
    
    public string? AutoProp { get; set; } = "";
    public string AutoReadOnlyProp { get; } = ""; // Can be assigned in ctor
    public string? AutoInitOnlyProp { get; init; }

    public required string RequiredProp { get; set; }
    
    public string ExpressionBodiedProp => "";
}

var p = new Person { FirstName = "Foo", LastName = "Bar" };
p.PropertyChanged += (s, ea) => Console.WriteLine($"{ea.PropertyName} changed");
p.LastName = "Baz";

class Person : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler? PropertyChanged;
    public string FullName => $"{LastName}, {FirstName}";
    public string FirstName
    {
        get;
        set
        {
            if (field != value)
            {
                field = value;
                PropertyChanged?.Invoke(this, new(nameof(FirstName)));
                PropertyChanged?.Invoke(this, new(nameof(FullName)));
            }
        }
    }

    public string LastName
    {
        // ... (like FirstName above)
    }
}

using System;
using static System.Console;

var aTuple = (number: 42, text: "Fourtytwo");
var (number, text) = aTuple;
WriteLine($"{number}; {text}");

int defaultNumber = default;
DateTime defaultDateTime = default;
string? defaultText = default;
WriteLine($"{defaultNumber}; {defaultDateTime}; {defaultText ?? "null"}");

(int, string?) tupleWithDefaults = (default, default);
(number, text) = tupleWithDefaults;
WriteLine($"{number}; {text ?? "null"}");

// And new is:
(int anotherNumber, string? anotherText) = default;
WriteLine($"{anotherNumber}; {anotherText ?? "null"}");
(number, text) = default;
WriteLine($"{number}; {text ?? "null"}");

class StampCollection
{
    private List<string> Collection { get; } = [];

    private object lockObject = new object();

    public void AddStamp(string stamp)
    {
        lock (lockObject)
        {
            Collection.Add(stamp);
        }
    }
}

class StampCollection
{
    private List<string> Collection { get; } = [];

    private Lock lockObject = new();

    public void AddStamp(string stamp)
    {
        lock (lockObject)
        {
            Collection.Add(stamp);
        }

		// Will lead to:
        //using(lockObject.EnterScope())
        //{
        //    Collection.Add(stamp);
        //}
    }
}

using Grade = decimal;

var dustin = new Student(12345, "Rainer Stropek");
dustin.AddGrades(4.0m, 3.8m, 3.9m);
Console.WriteLine(dustin.GPA);

public class Student(int id, string name)
{
    List<Grade> _grades = new();

    public void AddGrades(params Grade[] grades) => _grades.AddRange(grades);
    public void AddGrades(params IEnumerable<Grade> grades) => _grades.AddRange(grades);
    public void AddGrades(params ReadOnlySpan<Grade> grades) => _grades.AddRange(grades.ToArray());

    public int Id { get; } = id;

    public string Name { get; set; } = name;

    public Grade GPA => _grades switch
    {
    [] => 4.0m,
    [var grade] => grade,
        _ => _grades.Average()
    };
}

static class JsonString
{
    private static readonly JsonSerializerOptions s_indentedOptions = new() { WriteIndented = true };

    public static JsonElement ParseAsJson(this string s)
        => JsonDocument.Parse(s.Trim()).RootElement;

    public static string CreateIndented(JsonElement element)
        => element.ValueKind != JsonValueKind.Undefined
            ? JsonSerializer.Serialize(element, s_indentedOptions)
            : string.Empty;
}

var data = JsonData.ParseAsJson();
var json = string.CreateIndented(data);

var customers = data.GetProperty("customers");

foreach (Customer customer in customers.EnumerateArray())
{
    var name = customer.Name;
    WriteLine(name);

    foreach (var order in customer.Orders)
    {
        WriteLine($"{name} order {order.Description}");
    }
}

explicit extension Customer for JsonElement
{
    public string Name => this.GetProperty("name").GetString()!;
    public IEnumerable<Order> Orders => this.GetProperty("orders").EnumerateArray<Order>();
}

explicit extension Order for JsonElement
{
    public string Description => this.GetProperty("description").GetString()!;
}