using System;

using System.Diagnostics.CodeAnalysis;

using System.Runtime.CompilerServices;

using System.Runtime.InteropServices;

​

public class Program

{

    public static void Main()

    {

        var a = new TestBuffer();

        // var span = a[..];

        // span[0] = 'a';

        // span[1] = 'b';

        // span[2] = 'c';

        "abc".AsSpan().CopyTo(a[..]);

        Console.WriteLine($"a = '{a}'");

    }

}

​

[StructLayout(LayoutKind.Explicit, Size = sizeof(char) * TestBuffer.Length)]

public struct TestBuffer

{

    const int Length = 3;

    [FieldOffset(0)]

    char _;

    public char this[int index]

    {

        get => AsSpan()[index];

        set => AsSpan()[index] = value;

    }

    [UnscopedRef]

    public Span<char> this[Range range] => AsSpan()[range];

    [UnscopedRef]

    [MethodImpl(MethodImplOptions.AggressiveInlining)]

    public Span<char> AsSpan() => new SpanBuilder(ref _, Length);

    public override string ToString() => AsSpan().ToString();

}

​

[StructLayout(LayoutKind.Explicit)]

public readonly ref struct SpanBuilder(ref char reference, int length)

{

    [FieldOffset(0)]

    private readonly Span<char> _span;

    [FieldOffset(0)]

    private readonly SpanLayout _spanLayout = new(ref reference, length);

    private readonly ref struct SpanLayout(ref char reference, int length)

    {

        public readonly ref char Reference = ref reference;

        public readonly int Length = length;

    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]

    public static implicit operator Span<char>(SpanBuilder v) => v._span;

}

​

​

​

​

​

​

​

​

​

​

[InlineArray(80)]

public struct Buffer80

{

    char _;

}

​

​

​

[InlineArray(3)]

public struct Buffer3

{

    char _;

    public int Length => this[..].Length;

    public Buffer3(string value)

    {

        value.AsSpan().Slice(0, Math.Min(value?.Length ?? 0, this[..].Length)).CopyTo(this[..]);

        this[..].Replace(' ', '\0');

    }

    public readonly override string ToString()

    {

        Span<char> temp = stackalloc char[3];

        this[..].CopyTo(temp);

        temp.Replace('\0', ' ');

        return temp.ToString();

    }

    public static implicit operator string(Buffer3 v) => v.ToString();

    public static implicit operator Buffer3(string v) => new(v);

}

​

​

​

public readonly struct Code(string value)

{

    private readonly Buffer3 _value = value;

    public override string ToString() => _value;

    public static implicit operator Code(string v) => new(v);

    public static implicit operator string(Code v) => v.ToString();

}

​

​

​

[StructLayout(LayoutKind.Explicit)]

public readonly record struct Record()

{

    private static Record Default = new();

    public Record(Record original) : this() => this = original;

    [FieldOffset(0)]

    private readonly Buffer80 _value;

    public char this[int cardColumn]

    {

        get => _value[cardColumn - 1];

        init => _value[cardColumn - 1] = value;

    }

    [field: FieldOffset(0)]

    public Code Test1 { get; init; } = "ABC";

    [field: FieldOffset(10)]

    public char Test2 { get; init; }

    public override string ToString()

    {

        Span<char> temp = stackalloc char[80];

        Default._value[..].CopyTo(temp);

        return temp.ToString();

    }

}