Read-only, immutable and frozen collections

using System.Collections.ObjectModel;

// A timetable class keeps its stations in a list and hands out a read-only view of it.
List<string> stations = ["NDLS", "AGC", "GWL"];
ReadOnlyCollection<string> view = stations.AsReadOnly();
Console.WriteLine($"view                  Count {view.Count}: {string.Join(", ", view)}");

// The view refuses changes made through it...
try
{
    ((IList<string>)view).Add("JHS");
}
catch (NotSupportedException e)
{
    Console.WriteLine($"Add through the view  {e.GetType().Name}");
}

// ...but it is a window onto the list, so it shows every change its owner makes.
stations.Add("JHS");
stations[0] = "DLI";
Console.WriteLine($"after the owner's two changes  Count {view.Count}: {string.Join(", ", view)}");

// A reader in the middle of a foreach over the view feels the change too.
try
{
    foreach (string code in view)
    {
        if (code == "AGC")
        {
            stations.Add("BPL");   // the owner adds while someone reads
        }
    }
}
catch (InvalidOperationException e)
{
    Console.WriteLine($"owner adds during a reader's foreach  {e.GetType().Name}");
}

// The same holds for dictionaries: AsReadOnly gives a ReadOnlyDictionary over the same entries.
var platforms = new Dictionary<string, int> { ["12951"] = 1 };
IReadOnlyDictionary<string, int> platformView = platforms.AsReadOnly();
platforms["12002"] = 3;
Console.WriteLine($"ReadOnlyDictionary    Count {platformView.Count}, after the owner added a train");

// A copy is the only way to hand out stations that will not change afterwards.
string[] snapshot = [.. stations];
stations.Clear();
Console.WriteLine($"after Clear()         view Count {view.Count}, snapshot Length {snapshot.Length}");

view                  Count 3: NDLS, AGC, GWL
Add through the view  NotSupportedException
after the owner's two changes  Count 4: DLI, AGC, GWL, JHS
owner adds during a reader's foreach  InvalidOperationException
ReadOnlyDictionary    Count 2, after the owner added a train
after Clear()         view Count 0, snapshot Length 5

using System.Collections.Immutable;

// An immutable list never changes: every "change" returns a new list, and the old one stays as it was.
ImmutableList<string> v1 = ["NDLS", "AGC"];
ImmutableList<string> v2 = v1.Add("GWL");
ImmutableList<string> v3 = v2.SetItem(0, "DLI").Remove("AGC");
Console.WriteLine($"v1  {string.Join(", ", v1)}");
Console.WriteLine($"v2  {string.Join(", ", v2)}");
Console.WriteLine($"v3  {string.Join(", ", v3)}");

// Calling a method and dropping its result changes nothing, as with strings.
v1.Add("JHS");
Console.WriteLine($"after v1.Add(\"JHS\") on a line of its own, v1 still has {v1.Count} stations");

// ImmutableArray<T> is a struct around an array: fast to read, and every change copies the whole array.
ImmutableArray<int> fares = [450, 520, 610];
ImmutableArray<int> raised = fares.SetItem(0, 480);
Console.WriteLine($"fares [{string.Join(", ", fares)}], raised [{string.Join(", ", raised)}], fares[2] = {fares[2]}");

// Many changes at once: a builder collects them and makes one immutable result.
ImmutableArray<int>.Builder builder = ImmutableArray.CreateBuilder<int>(5);
for (int seat = 1; seat <= 5; seat++)
{
    builder.Add(seat * 10);
}
ImmutableArray<int> seats = builder.MoveToImmutable();
Console.WriteLine($"from a builder        [{string.Join(", ", seats)}], builder Count now {builder.Count}");

// Two lists that look equal are still compared by reference, unless you compare their items.
ImmutableList<string> again = ["NDLS", "AGC"];
Console.WriteLine($"v1 == again: {v1 == again}; same items: {v1.SequenceEqual(again)}");

v1  NDLS, AGC
v2  NDLS, AGC, GWL
v3  DLI, GWL
after v1.Add("JHS") on a line of its own, v1 still has 2 stations
fares [450, 520, 610], raised [480, 520, 610], fares[2] = 610
from a builder        [10, 20, 30, 40, 50], builder Count now 0
v1 == again: False; same items: True

using System.Collections.Frozen;

// Station codes and names, loaded once when a service starts and read on every request after that.
var source = new Dictionary<string, string>
{
    ["NDLS"] = "New Delhi",
    ["MAS"] = "Chennai Central",
    ["HWH"] = "Howrah",
    ["SBC"] = "KSR Bengaluru",
    ["CSMT"] = "Mumbai CSMT",
};

FrozenDictionary<string, string> stations = source.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);
Console.WriteLine($"Count {stations.Count}; stations[\"ndls\"] = {stations["ndls"]}; TryGetValue(\"BPL\") {stations.TryGetValue("BPL", out _)}");

// A frozen dictionary has no Add or Remove, and its interface methods that would change it throw.
try
{
    ((IDictionary<string, string>)stations).Add("BPL", "Bhopal");
}
catch (NotSupportedException e)
{
    Console.WriteLine($"Add through IDictionary  {e.GetType().Name}");
}

// Changing the source afterwards does not reach the frozen copy.
source["BPL"] = "Bhopal";
Console.WriteLine($"source has {source.Count} keys, the frozen dictionary still {stations.Count}");

// When it is created, it looks at the keys it was given and picks a lookup strategy for them.
Console.WriteLine($"picked for these keys    {stations.GetType().Name}");

// FrozenSet<T> is the same idea for a set.
FrozenSet<string> junctions = new[] { "NDLS", "ET", "BZA", "NGP" }.ToFrozenSet();
Console.WriteLine($"FrozenSet Contains(\"ET\") {junctions.Contains("ET")}, Contains(\"et\") {junctions.Contains("et")}: no comparer, so case counts");

Count 5; stations["ndls"] = New Delhi; TryGetValue("BPL") False
Add through IDictionary  NotSupportedException
source has 6 keys, the frozen dictionary still 5
picked for these keys    LengthBucketsFrozenDictionary`1
FrozenSet Contains("ET") True, Contains("et") False: no comparer, so case counts

using System.Collections.Frozen;

// Practice: write BuildLookup so that every check below passes, then run this file again.
// BuildLookup turns the rows of a station file into a lookup from code to name that is built once at start-up and
// then only read, by many threads: a FrozenDictionary that finds a code whatever its case.
(string Code, string Name)[] rows = [("NDLS", "New Delhi"), ("MAS", "Chennai Central"), ("HWH", "Howrah")];

var checks = new List<(string Name, Func<string> Run, string Expected)>
{
    ("finds NDLS", () => BuildLookup(rows)["NDLS"], "New Delhi"),
    ("finds mas in lower case", () => BuildLookup(rows)["mas"], "Chennai Central"),
    ("misses BPL without throwing", () => BuildLookup(rows).TryGetValue("BPL", out _).ToString(), "False"),
    ("holds three stations", () => BuildLookup(rows).Count.ToString(), "3"),
    ("refuses Add", () =>
    {
        IDictionary<string, string> asDictionary = BuildLookup(rows);
        try
        {
            asDictionary.Add("BPL", "Bhopal");
            return "added";
        }
        catch (NotSupportedException)
        {
            return "refused";
        }
    }, "refused"),
    ("an empty file", () => BuildLookup([]).Count.ToString(), "0"),
};

int passed = 0;
foreach (var (name, run, expected) in checks)
{
    string verdict;
    try
    {
        string got = run();
        verdict = got == expected ? "ok" : $"FAIL, got \"{got}\"";
    }
    catch (Exception e)
    {
        verdict = $"FAIL, {e.GetType().Name}";
    }
    if (verdict == "ok")
    {
        passed++;
    }
    Console.WriteLine($"{name}: {verdict}");
}
Console.WriteLine($"{passed} of {checks.Count} checks pass");
return passed == checks.Count ? 0 : 1;

static FrozenDictionary<string, string> BuildLookup(IEnumerable<(string Code, string Name)> rows)
{
    throw new NotImplementedException("Make key-value pairs from the rows, then call ToFrozenDictionary with a comparer.");
}

finds NDLS: FAIL, NotImplementedException
finds mas in lower case: FAIL, NotImplementedException
misses BPL without throwing: FAIL, NotImplementedException
holds three stations: FAIL, NotImplementedException
refuses Add: FAIL, NotImplementedException
an empty file: FAIL, NotImplementedException
0 of 6 checks pass