C# Language Support

#if TRANSPOSE
    Console.WriteLine("running in the browser");
#else
    Console.WriteLine(File.ReadAllText("settings.json"));
#endif

using System;
using System.Linq;

public record Point(int X, int Y)
{
    public double Length => Math.Sqrt(X * X + Y * Y);
}

public readonly record struct Money(decimal Amount, string Currency);

public abstract class Shape { public abstract double Area(); }
public sealed class Circle(double r) : Shape { public override double Area() => Math.PI * r * r; }
public sealed class Rect(double w, double h) : Shape { public override double Area() => w * h; }

public class Program
{
    static string Describe(object o) => o switch
    {
        null => "null",
        int n when n < 0 => "negative int",
        int n => $"int {n}",
        Point { X: 0, Y: 0 } => "origin",
        Point(var x, var y) => $"point {x},{y}",
        string { Length: > 5 } s => $"long string {s}",
        int[] and [1, .., var last] => $"array ending in {last}",
        _ => "something else",
    };

    public static void Main()
    {
        var p = new Point(3, 4);
        var q = p with { Y = 0 };
        Console.WriteLine($"{p} {q} {p.Length} {p == new Point(3, 4)}");
        Console.WriteLine(new Money(12.50m, "EUR"));

        Shape[] shapes = [new Circle(1), new Rect(2, 3)];
        Console.WriteLine(shapes.Sum(s => s.Area()).ToString("F2"));

        foreach (var o in new object[] { null, -1, 7, new Point(0, 0), new Point(1, 2), "abcdefg", new[] { 1, 2, 3 }, 1.5 })
            Console.WriteLine(Describe(o));

        var (a, b) = (1, "two");
        Console.WriteLine($"{a} {b}");

        int[] arr = [1, 2, 3, .. new[] { 4, 5 }];
        Console.WriteLine(string.Join(",", arr[1..^1]));

        string? maybe = null;
        maybe ??= "default";
        Console.WriteLine(maybe?.ToUpper());

        var raw = """
            {"name": "raw"}
            """;
        Console.WriteLine(raw);
    }
}

Point { X = 3, Y = 4, Length = 5 } Point { X = 3, Y = 0, Length = 3 } 5 True
Money { Amount = 12.50, Currency = EUR }
9.14
null
negative int
int 7
origin
point 1,2
long string abcdefg
array ending in 3
something else
1 two
2,3,4
DEFAULT
{"name": "raw"}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

public class Counter
{
    public event EventHandler<int>? Changed;
    private int _value;
    public int Value
    {
        get => _value;
        set { _value = value; Changed?.Invoke(this, value); }
    }
}

public struct Vec(double x, double y)
{
    public double X = x, Y = y;
    public static Vec operator +(Vec a, Vec b) => new(a.X + b.X, a.Y + b.Y);
    public override string ToString() => $"({X}, {Y})";
}

public class Matrix
{
    private readonly double[,] _cells = new double[2, 2];
    public double this[int r, int c] { get => _cells[r, c]; set => _cells[r, c] = value; }
}

public static class StringExtensions
{
    public static string Shout(this string s) => s.ToUpper() + "!";
}

public class Program
{
    static IEnumerable<int> Fib()
    {
        int a = 0, b = 1;
        while (true) { yield return a; (a, b) = (b, a + b); }
    }

    static T Max<T>(T a, T b) where T : IComparable<T> => a.CompareTo(b) >= 0 ? a : b;

    static async Task<int> SlowAdd(int a, int b)
    {
        await Task.Delay(10);
        return a + b;
    }

    public static async Task Main()
    {
        Console.WriteLine(string.Join(" ", Fib().Take(10)));
        Console.WriteLine(Max("apple", "pear") + " " + Max(3, 9));

        var c = new Counter();
        c.Changed += (_, v) => Console.WriteLine($"changed to {v}");
        c.Value = 42;

        var v = new Vec(1, 2);
        var w = v;          // a struct assignment copies the value
        w.X = 100;
        Console.WriteLine($"{v} {w} {v + w}");

        var m = new Matrix();
        m[1, 1] = 5;
        Console.WriteLine(m[1, 1]);

        Console.WriteLine("hello".Shout());

        var query = from n in Enumerable.Range(1, 10)
                    where n % 2 == 0
                    let sq = n * n
                    orderby sq descending
                    select new { n, sq };
        Console.WriteLine(string.Join(", ", query.Select(x => $"{x.n}:{x.sq}")));

        int Local(int x) => x * 2;
        Console.WriteLine(Local(21));

        var results = await Task.WhenAll(SlowAdd(1, 2), SlowAdd(3, 4));
        Console.WriteLine(string.Join(",", results));

        try { throw new InvalidOperationException("boom"); }
        catch (InvalidOperationException ex) when (ex.Message == "boom") { Console.WriteLine("filtered: " + ex.Message); }
        finally { Console.WriteLine("finally"); }

        long big = long.MaxValue;
        decimal price = 0.1m + 0.2m;
        Console.WriteLine($"{big} {price} {0.1 + 0.2}");
    }
}

0 1 1 2 3 5 8 13 21 34
pear 9
changed to 42
(1, 2) (100, 2) (101, 4)
5
HELLO!
10:100, 8:64, 6:36, 4:16, 2:4
42
3,7
filtered: boom
finally
9223372036854775807 0.3 0.30000000000000004

static void Swap(ref int a, ref int b) => (a, b) = (b, a);
static bool TryHalf(int x, out int half) { half = x / 2; return x % 2 == 0; }

int a = 1, b = 2;
Swap(ref a, ref b);                                  // a = 2, b = 1
if (TryHalf(10, out var h)) Console.WriteLine(h);    // 5

public class Buffer
{
    private readonly int[] _items = { 1, 2, 3 };
    public ref int this[int i] => ref _items[i];
    public ref int Find(int value) { /* … */ return ref _items[0]; }
}

int[] values = { 1, 2, 3 };
ref int first = ref values[0];
first = 10;                        // values[0] is 10

var buffer = new Buffer();
buffer[1] = 20;                    // assigns through the ref-returning indexer
buffer.Find(3) = 30;               // assigns through the ref-returning method
ref int slot = ref buffer[2];
slot++;

public class Foo
{
    public int A; public string B;
    public void Deconstruct(out int a, out string b) { a = A; b = B; }
}

public static class VersionExtensions
{
    public static void Deconstruct(this Version v, out int major, out int minor)
        => (major, minor) = (v.Major, v.Minor);
}

var label = o switch
{
    Foo(1, "a") => "one",
    Foo(var a, _) when a > 5 => "big",
    _ => "other",
};
Console.WriteLine(new Version(2024, 5) is (2024, 5));   // True

static int Sum(params ReadOnlySpan<int> xs) { var t = 0; foreach (var x in xs) t += x; return t; }

int[] values = { 1, 2, 3, 4 };
Span<int> tail = values.AsSpan(2);
tail.Fill(0);                              // values is 1, 2, 0, 0
foreach (ref var x in values.AsSpan()) x *= 10;

Span<int> buffer = stackalloc int[4];
ReadOnlySpan<byte> utf8 = "héllo"u8;       // 6 bytes
Console.WriteLine(Sum(1, 2, 3));           // 6
Console.WriteLine("  yes ".AsSpan().Trim() is "yes");   // True