How to pass ref struct parameter to MethodInfo if struct has ReadOnlySpan field

Since you are structnaturally going to be a ref structthat will live on the stack (and cannot go to the managed heap), you face some compiler limitations, and there are some hurdles to overcome.

• A reference structure cannot be an element type of an array.
• A reference struct cannot be the declared type of a class or a field of a non-reference struct.
• A reference struct cannot implement an interface.
• Reference structures cannot be boxed to System.ValueType or System.Object.
• A reference structure cannot be a type parameter. ref struct variables cannot be captured by vlambda expressions or local functions.
• ref struct variables cannot be used in async methods. However, you can use ref struct variables in synchronized methods, for example, in methods that return Task or Task.
• ref struct variables cannot be used in iterators.

As you can see, ref structcannot be boxed on heap. You will not be able to, which means to vote and use . However, you can use an expression tree orobjectInvokerelection.emit

When using an expression tree , you will need to use a delegate that cannot be used as a Expression.Lambdatype parameter .ref structFunc

given

public readonly ref struct Bob
{
   public Bob(ReadOnlySpan<byte> myProperty)
      => MyProperty = myProperty;    

   public ReadOnlySpan<byte> MyProperty { get; }
}

...

public static byte DoSomething(Bob bob)
   => bob.MyProperty[1]; // return something from the span ¯\_(ツ)_/¯

delegate byte myDelegate(Bob asd);

...

var bytes = new byte[] {1, 2, 3};
var span = bytes.AsSpan();
var bob = new Bob(span);

usage

var method = typeof(SomeType).GetMethod("DoSomething");
var parameter = Expression.Parameter(typeof(Bob), "b");
var call = Expression.Call(method, parameter);
var expression = Expression.Lambda<myDelegate>(call, parameter);
var func = expression.Compile();
var result = func(bob);

Console.WriteLine(result);

result

2

or with the in parameter modifier, you need to take advantage ofMakeByRefType

When passed as a ref parameter, returns a Type object representing the current type

public static byte DoSomething(in Bob bob)
  => bob.MyProperty[1]; // return something from the span ¯\_(ツ)_/¯

delegate byte myDelegate(in Bob asd);

...

var method = typeof(SomeType).GetMethod("DoSomething", new[] {typeof(Bob).MakeByRefType()});
var parameter = Expression.Parameter(typeof(Bob).MakeByRefType(), "b");
var call = Expression.Call(method, parameter);
var expression = Expression.Lambda<myDelegate>(call, parameter);
var func = expression.Compile();
var result = func(bob);

_{Note : This code is not fortress perfect expression, but it should work. Also, this is built for staticmethods , if not, you need to pass in an instance}