How to create a delegate for a generic method that requires casting back and forth

Question

I have a method:

MyMethod<T>(T) where T: struct, MyInterface

I have a target delegate as:

public delegate void MyDelegate(object myObject)

I have a collection of Types that are both structs and implement MyInterface

So invoking MyMethod is as simple as:

myMethodInfo.MakeGenericMethod(myType).Invoke(target, new object[]{myObject})

that is, because Invoke accepts object and does the casting for me somewhere in the internal code.

The issue is that I can't seem to make a delegate like MyDelegate(object) because object is not struct, MyInterface

I get why

(MyDelegate)addComponentData.MakeGenericMethod(MyType).CreateDelegate(typeof(MyDelegate), target)

does not work, but I have no idea how to solve it

The reason I need this is because every time I am using any of these objects, I am using them as MyInterface, I have no idea which type they are, only that they implement MyInterface and are structs, therefore they are eligible for the method I need to invoke them on. To make all of this reflection faster, I want to use CreateDelegate, as it seems it is only twice as slow as an actual normal invocation of the method where MethodInfo.Invoke is 100 times slower (source: Is the use of dynamic considered a bad practice?)

Interesting question but why is it a requirement to do all this through reflection? — JSteward, Aug 30 '19 at 21:40
because the list of types is created at runtime using runtime code compilation. — Guedez, Aug 30 '19 at 21:54

score 1 · Accepted Answer · answered Aug 30 '19 at 21:31

1

Make wrapper method that takes an object and use it to construct delegate:

public void Wrapper<T>(object s) where T : struct, MyInterface
{
    MyMethod<T>((T)s);
}

answered Aug 30 '19 at 21:31

Alexei Levenkov

98,904
14
127
179

the wrapper method will inevitably have to use Invoke, which is 100 times slower than CreateDelegate. If I were to do this, I would just use Invoke – Guedez Aug 30 '19 at 21:36
It's calling `Invoke` on the delegate that points to `Wrapper`, not a `MethodInfo`. Big difference. – madreflection Aug 30 '19 at 21:38
@Guedez ? why can't you use the same code you had in the question like - `(MyDelegate)methodInfoForWrapper.MakeGenericMethod(MyType).CreateDelegate(typeof(MyDelegate), target)` to create delegate? I'm clearly missed something from your question then - consider to edit the question to clarify restrictions. – Alexei Levenkov Aug 30 '19 at 21:41
After some preliminary checks, it seems to be working, I will finish some more tests and mark as the answer – Guedez Aug 30 '19 at 21:57
Worked like a charm, funny how a solution so simple slipped past my mind for so long – Guedez Aug 30 '19 at 22:03

score 0 · Answer 2 · answered Aug 30 '19 at 21:32

0

The only point of using a struct generic method constraint is to avoid boxing. You aren't avoiding boxing. So just declare the method as:

MyMethod(MyInterface obj)

answered Aug 30 '19 at 21:32

David Browne - Microsoft

80,331
6
39
67

It's not my method, it's from a library – Guedez Aug 30 '19 at 21:35

How to create a delegate for a generic method that requires casting back and forth

2 Answers2