TypedRef

Author: ufcpp

Demo/2025/RefReflection/ConsoleApp1/ConsoleApp1.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

Demo/2025/RefReflection/ConsoleApp1/ITupleAccessor.cs

@@ -0,0 +1,7 @@
+namespace ConsoleApp1;
+
+public interface ITupleAccessor
+{
+    int Length { get; }
+    TypedRef this[int index] { get; }
+}

Demo/2025/RefReflection/ConsoleApp1/Program.cs

@@ -0,0 +1,44 @@
+using ConsoleApp1;
+using System.Runtime.CompilerServices;
+
+M(1, 2);
+M("1", 2.0);
+M(true, DateTimeOffset.Now);
+M((byte)1, (short)2, (ushort?)3);
+
+partial class Program
+{
+    public static void M<T1, T2>(T1 x1, T2 x2)
+    {
+        var tuple = (x1, x2);
+        var accessor = Accessor.Create(ref tuple);
+        A(tuple); // boxed
+        B(accessor);
+        Console.WriteLine();
+    }
+
+    public static void M<T1, T2, T3>(T1 x1, T2 x2, T3 x3)
+    {
+        var tuple = (x1, x2, x3);
+        var accessor = Accessor.Create(ref tuple);
+        A(tuple); // boxed
+        B(accessor);
+    }
+
+    static void A(ITuple tuple)
+    {
+        for (int i = 0; i < tuple.Length; i++)
+        {
+            Console.WriteLine(tuple[i]?.GetType().Name);
+        }
+    }
+
+    static void B<TAccessor>(TAccessor tuple)
+        where TAccessor : struct, ITupleAccessor, allows ref struct
+    {
+        foreach (var t in tuple)
+        {
+            Console.WriteLine(t.Type.Name);
+        }
+    }
+}

Demo/2025/RefReflection/ConsoleApp1/TupleAccessor2.cs

@@ -0,0 +1,18 @@
+namespace ConsoleApp1;
+
+public readonly ref struct TupleAccessor<T1, T2>(ref (T1, T2) tuple) : ITupleAccessor
+{
+    private readonly ref (T1, T2) _tuple = ref tuple;
+    public readonly int Length => 2;
+    public TypedRef this[int index] => index switch
+    {
+        0 => TypedRef.Create(ref _tuple.Item1),
+        1 => TypedRef.Create(ref _tuple.Item2),
+        _ => throw new IndexOutOfRangeException(),
+    };
+}
+
+partial class Accessor
+{
+    public static TupleAccessor<T1, T2> Create<T1, T2>(ref this (T1, T2) tuple) => new(ref tuple);
+}

Demo/2025/RefReflection/ConsoleApp1/TupleAccessor3.cs

@@ -0,0 +1,19 @@
+namespace ConsoleApp1;
+
+public readonly ref struct TupleAccessor<T1, T2, T3>(ref (T1, T2, T3) tuple) : ITupleAccessor
+{
+    private readonly ref (T1, T2, T3) _tuple = ref tuple;
+    public readonly int Length => 3;
+    public TypedRef this[int index] => index switch
+    {
+        0 => TypedRef.Create(ref _tuple.Item1),
+        1 => TypedRef.Create(ref _tuple.Item2),
+        2 => TypedRef.Create(ref _tuple.Item3),
+        _ => throw new IndexOutOfRangeException(),
+    };
+}
+
+partial class Accessor
+{
+    public static TupleAccessor<T1, T2, T3> Create<T1, T2, T3>(ref this (T1, T2, T3) tuple) => new(ref tuple);
+}

Demo/2025/RefReflection/ConsoleApp1/TupleEnumerator.cs

@@ -0,0 +1,21 @@
+namespace ConsoleApp1;
+
+public ref struct TupleEnumerator<TAccessor>(TAccessor tuple)
+    where TAccessor : struct, ITupleAccessor, allows ref struct
+{
+    private TAccessor _tuple = tuple;
+    private int _index = -1;
+
+    public bool MoveNext()
+    {
+        return ++_index < _tuple.Length;
+    }
+    public TypedRef Current => _tuple[_index];
+}
+
+public static partial class Accessor
+{
+    public static TupleEnumerator<TAccessor> GetEnumerator<TAccessor>(this TAccessor tuple)
+       where TAccessor : struct, ITupleAccessor, allows ref struct
+        => new(tuple);
+}

Demo/2025/RefReflection/ConsoleApp1/TypedRef.cs

@@ -0,0 +1,45 @@
+using System.Runtime.CompilerServices;
+
+namespace ConsoleApp1;
+
+/// <summary>
+/// 型情報 + ref。
+/// </summary>
+/// <remarks>
+/// object だと値型の処理が悲惨なので ref で untyped にやり取りするための型を用意。
+///
+/// 中身、<see cref="TypedReference"/> とほぼ一緒。
+/// ただ、そっちは ref field 実装前からあるせいで相当特別な制限かかってて使いづらい。
+///
+/// 名前一緒だと混乱しそうなのであえて省略形。
+/// </remarks>
+public readonly ref struct TypedRef(Type type, ref byte r)
+{
+    public readonly Type Type = type;
+    public readonly UnsafeRef UnsafeReference = new(ref r);
+
+    public static TypedRef Create<T>(ref T value)
+    {
+        return new TypedRef(typeof(T), ref Unsafe.As<T, byte>(ref value));
+    }
+
+    public ref T As<T>()
+    {
+        if (typeof(T) != Type) ThrowTypeNotMatched();
+        return ref UnsafeReference.As<T>();
+    }
+
+    public void Set<T>(T value)
+    {
+        if (!typeof(T).IsAssignableTo(Type)) ThrowTypeNotMatched();
+        UnsafeReference.As<T>() = value;
+    }
+
+    public T Get<T>()
+    {
+        if (!typeof(T).IsAssignableFrom(Type)) ThrowTypeNotMatched();
+        return UnsafeReference.As<T>();
+    }
+
+    private void ThrowTypeNotMatched() => throw new InvalidCastException();
+}

Demo/2025/RefReflection/ConsoleApp1/UnsafeRef.cs

@@ -0,0 +1,21 @@
+using System.Runtime.CompilerServices;
+
+namespace ConsoleApp1;
+
+/// <summary>
+/// ref。
+/// </summary>
+/// <remarks>
+/// Unsafe.As&lt;T, byte&gt; で ref byte 化して参照を持つ。
+/// ほぼ managed ポインター。
+/// ref byte 直伝搬よりはマシ、程度。
+/// </remarks>
+public readonly ref struct UnsafeRef(ref byte r)
+{
+    public readonly ref byte UnsafeReference = ref r;
+
+    public ref T As<T>()
+    {
+        return ref Unsafe.As<byte, T>(ref UnsafeReference);
+    }
+}

Demo/2025/RefReflection/RefReflection.slnx

@@ -0,0 +1,3 @@
+<Solution>
+  <Project Path="ConsoleApp1/ConsoleApp1.csproj" />
+</Solution>