Creates a method description for name, which conforms to the following specification:

[namespace.]classname:methodname[(args...)]

in all the loaded assemblies.

Both classname and methodname can contain * which matches anything.

This method is used to check whether the method matches the provided description, by making sure that the method matches both the class and the method parameters.

Determines whether the specified method matches the provided desc description.

namespace and class are supposed to match already if this function is used.

Returns an unmanaged->managed thunk that can be used to call a managed method directly from C.

The thunk's C signature closely matches the managed signature:

C#: public bool Equals (object obj);

C: typedef MonoBoolean (*Equals)(MonoObject*, MonoObject*, MonoException**);

The 1st (this) parameter must not be used with static methods:

C#: public static bool ReferenceEquals (object a, object b);

C: typedef MonoBoolean (*ReferenceEquals)(MonoObject*, MonoObject*, MonoException**);

The last argument must be a non-null MonoException* pointer. It has "out" semantics. After invoking the thunk, *ex will be NULL if no exception has been thrown in managed code. Otherwise it will point to the MonoException* caught by the thunk. In this case, the result of the thunk is undefined:

 MonoMethod *method = ... // MonoMethod* of System.Object.Equals

 MonoException *ex = NULL;

 Equals func = mono_method_get_unmanaged_thunk (method);

 MonoBoolean res = func (thisObj, objToCompare, &ex);

 if (ex) {

    // handle exception

 }
 

The calling convention of the thunk matches the platform's default convention. This means that under Windows, C declarations must contain the __stdcall attribute:

C: typedef MonoBoolean (__stdcall *Equals)(MonoObject*, MonoObject*, MonoException**);

LIMITATIONS

Value type arguments and return values are treated as they were objects:

C#: public static Rectangle Intersect (Rectangle a, Rectangle b); C: typedef MonoObject* (*Intersect)(MonoObject*, MonoObject*, MonoException**);

Arguments must be properly boxed upon trunk's invocation, while return values must be unboxed.

The params array contains the arguments to the method with the same convention: MonoObject* pointers for object instances and pointers to the value type otherwise.

From unmanaged code you'll usually use the mono_runtime_invoke variant.

Note that this function doesn't handle virtual methods for you, it will exec the exact method you pass: we still need to expose a function to lookup the derived class implementation of a virtual method (there are examples of this in the code, though).

You can pass NULL as the exc argument if you don't want to catch exceptions, otherwise, *exc will be set to the exception thrown, if any. if an exception is thrown, you can't use the MonoObject* result from the function.

If the method returns a value type, it is boxed in an object reference.

obj is the this pointer, it should be NULL for static methods, a MonoObject* for object instances and a pointer to the value type for value types.

The params array contains the arguments to the method with the same convention: MonoObject* pointers for object instances and pointers to the value type otherwise. The _invoke_array variant takes a C# object[] as the params argument (MonoArray*): in this case the value types are boxed inside the respective reference representation.

From unmanaged code you'll usually use the mono_runtime_invoke_checked() variant.

Note that this function doesn't handle virtual methods for you, it will exec the exact method you pass: we still need to expose a function to lookup the derived class implementation of a virtual method (there are examples of this in the code, though).

You can pass NULL as the exc argument if you don't want to catch exceptions, otherwise, *exc will be set to the exception thrown, if any. if an exception is thrown, you can't use the MonoObject* result from the function.

If the method returns a value type, it is boxed in an object reference.

Invokes the delegate method delegate with the parameters provided.

You can pass NULL as the exc argument if you don't want to catch exceptions, otherwise, *exc will be set to the exception thrown, if any. if an exception is thrown, you can't use the MonoObject* result from the function.

Get the info about the exception clauses in the method. Set *iter to NULL to initiate the iteration, then call the method repeatedly until it returns FALSE. At each iteration, the structure pointed to by clause if filled with the exception clause information.

Method header accessor to retreive info about the IL code properties: a pointer to the IL code itself, the size of the code and the max number of stack slots used by the code.

Method header accessor to retreive info about the local variables: an array of local types, the number of locals and whether the locals are supposed to be initialized to 0 on method entry