using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

BenchmarkRunner.Run<SwitchVsVirtual>();

public class SwitchVsVirtual
{
    private readonly Base[] _vData;
    private readonly SwitchData[] _sData;
    
    public SwitchVsVirtual()
    {
        var rnd = new Random(Environment.TickCount);
        var randoms = Enumerable.Range(0, 10000).Select(_ => rnd.Next(0, 3)).ToArray();
        _vData = randoms
            .Select(r => r switch { 
                0 => (Base)new DerivedA(),
                1 => new DerivedB(),
                2 => new DerivedC(),
                _ => throw new ArgumentOutOfRangeException()
            })
            .ToArray();
        _sData = randoms
            .Select(r => new SwitchData(r switch { 
                0 => Discriminant.A,
                1 => Discriminant.B,
                2 => Discriminant.C,
                _ => throw new ArgumentOutOfRangeException()
            }))
            .ToArray();
    }

    [Benchmark]
    public int Virtual()
    {
        var res = 0;
        foreach (var data in _vData)
            res += data.Data.Length;
        return res;
    }

    [Benchmark]
    public int Switch()
    {
        var res = 0;
        foreach (var d in _sData)
            res += d.Data.Length;
        return res;
    }
}

abstract class Base
{
    public abstract string Data { get; }
}

class DerivedA : Base
{
    public override string Data => "A";
}

class DerivedB : Base
{
    public override string Data => "B";
}

class DerivedC : Base
{
    public override string Data => "C";
}

enum Discriminant { A, B, C }

record SwitchData(Discriminant Discriminant)
{
    public string Data =>
        Discriminant switch
        {
            Discriminant.A => "A",
            Discriminant.B => "B",
            Discriminant.C => "C",
            _ => throw new ArgumentOutOfRangeException()
        };
}