Q: Why cannot box Span<T>?

[nathan130200]

I was creating static cache for types and its converters that uses BinaryPrimitives, Span<T> and ReadOnlySpan<T> but i cannot just box Span and ReadOnlySpan into object (base class?) for dynamic invoke function to converter T (primitives: int, short, long, uint, ushort, ulong).

delegate T Decoder<T>(ReadOnlySpan<byte> span);

var decoders = new Dictionary<Type, Delegate>()
{
  [typeof(int)] = new Decoder<int>(BinaryPrimitives.ReadInt32BitEndian)
};

var type = typeof(int);
var fn = decoders[type];
var buf = new byte[4]{1, 2, 3, 4};
var result = (int) fn.DynamicInvoke(buf.AsSpan()); // compile error: Cannot cast ReadOnlySpan<byte> to object

Don't work separate span into variable like:

var span = buf.AsSpan();
var result = (int) fn.DynamicInvoke(span);

Same happened with Span<T> i'm unable to use in DynamicInvoke for call function, and function for BinaryPrimitives only accept Span's

Why cannot just cast to base class

[HaloFour]

See: https://learn.microsoft.com/en-us/archive/msdn-magazine/2018/january/csharp-all-about-span-exploring-a-new-net-mainstay

These references are called interior pointers, and tracking them is a relatively expensive operation for the .NET runtime’s garbage collector. As such, the runtime constrains these refs to only live on the stack, as it provides an implicit low limit on the number of interior pointers that might be in existence.

As a result, Span instances can only live on the stack, not on the heap. This means you can’t box spans (and thus can’t use Span with existing reflection invoke APIs, for example, as they require boxing). It means you can’t have Span fields in classes, or even in non-ref-like structs. It means you can’t use spans in places where they might implicitly become fields on classes, for instance by capturing them into lambdas or as locals in async methods or iterators (as those “locals” may end up being fields on the compiler-generated state machines.) It also means you can’t use Span as a generic argument, as instances of that type argument could end up getting boxed or otherwise stored to the heap (and there’s currently no “where T : ref struct” constraint available).

[HaloFour]

You can't use DynamicInvoke with those types, you'll have to use Invoke directly on a proper delegate type.

[nathan130200]

I cant still use Invoke. This still requires Span to be boxed to object before call.

[nathan130200]

Cannot implicit cast ReadOnlySpan<byte> to object.

[HaloFour]

Yes, these reflective calls are illegal. You need to cast the delegate instance back to a proper delegate type and invoke it directly:

static T ReadValue<T>(ReadOnlySpan<byte> span) {
    var fn = (Decoder<T>) decoders[typeof(T)];
    return fn(span);
}

[nathan130200]

Oh my, really 😂 I hadn't even seen that. In my mind I was still doing reflection to access the function. Thanks for help.