Allow the calling of .Net instance methods from c++

[RoryBecker]

Firstly many thanks to @jkotas for his most helpful answer over here -> #99203
Possibly this previous question/answer will provide some additional context for this idea.

Currently I can...

• call coreclr_create_delegate and retrieve the address of a static c# method
• execute a call to that method.

I would very much like to be able to do the same with instance methods.

It seems that the coreclr_create_delegate does not support this at present.
I would very much like to be able to do this. (through this call, or another if more appropriate.

Is there any interest within the current set of developers in making this work?
Alternatively, is there a recommended path to learn about this area, that I might help to make this a reality.

Many thanks in advance for any help in this area.

[RoryBecker]

It seems a previous issue ( #12040 ) also addressed a similar request.

You can create a static method, get a pointer to it via coreclr_create_delegate and that static method can create the instance of the object you need, wrap the result in GCHandle, and do anything else.

It is intentional that coreclr_create_delegate handles just the simple case of static methods.

Does this mean that it is possible to use the GCHandle to access and invoke methods on the object in question?

Until I saw the referenced issue I had assumed that the GCHandle was limited to providing a means to prevent C# objects from being cleared up whilst another environment (c++) was still using them.

If it can be used to access and invoke instance methods, I would be very interested in this as I believe already have a GCHandle to my instanced object. (FYI: I have this through an existing call to the constructor (.ctor) of the object I'd like to call instance methods on.)

[huoyaoyuan]

I had assumed that the GCHandle was limited to providing a means to prevent C# objects from being cleared up whilst another environment (c++) was still using them.

You can't directly get an address of managed object into unmanaged code, because GC will loose track of it. GC can move an object and invalidate the address acquired previously. A GCHandle provides an indirect reference to the object. The address of the object is updating while the value of GCHandle is invariant.

It's not trivial access and requires generating code to get the managed object from the GCHandle. If you can write a managed wrapper doing this, it will be more friendly to the toolchain.