Methods
	Methods are represented by the 
MonoMethod*
	instances.  Various APIs surface these instances, but usually
	you will use the 
method description
	API to get a handle to a Mono Method.   You can 
invoke those methods from C,
	or you can probe 
probe various properties of a method, and in particular
	its 
method signature or get
	some 
low-level information about them.
	
The following code snippet from the Mono runtime shows you
	how to create a managed 
System.Version instance
	with four integers by looking up the constructor in the
	managed implementation of System.Version, creating an instance
	of the object, and then invoking the constructor on it.
	
	
Method Descriptions
	Methods are represented by the 
MonoMethod*
	instances.  To simplify the process of getting
	a 
MonoMethod*, you use Method Descriptors, which
	are C-strings that describe the method that you are looking
	for, and then you perform a search in either
	a 
type, or a
	loaded 
image.
	
	
To describe a method, you use the Method Description API.
	Method descriptions are used to locate a method in the
	executing program.   They can either be fully specified, that
	is, they would include the namespace, class, method name and
	all of its arguments or they omit the namespace and arguments
	and even use wildcard matches for the class name and method names.
	
You use the fully specified version to identify a
	particular method, or you can use the partial version to find
	a method or a family of methods in the code.   
	
Method descriptions are typically created from a C string
	representation, and take the following form:
	
[namespace.]classname:methodname[(args...)]
	Both classname and methodname can contain the '*' character
	which can be used to match anything.  Arguments are separated
	by commas.
	
You can use the type shortcuts to match the fully qualified
	parameter types.  The supported type shortcuts are:
        
char,
        
bool,
        
byte,
        
sbyte,
        
uint16,
        
int16,
        
uint,
        
int,
        
ulong,
        
long,
        
uintptr,
        
intptr,
        
single,
        
double,
        
string and 
        
object.
	
The type parameters can use the "&" and "*" type modifiers.
	
	
Examples of method descriptions:
	
		- "Monitor:Exit": matches classes and methods called "Monitor.Exit"
		
- "Monitor:enter_with_atomic_var(object,bool&)":
		matches a method in the class Monitor with two
		specific type parameters.
		
- ":.ctor(int,int,int,int)": matches constructors
		that take four integers.
		
- "System.Globalization.CultureInfo:CreateCulture(string,bool)":
		matches the CreateCultureMethod that takes a string
		and a boolean on the System.Globalization.CultureInfo class.
	
You can
	then 
search for
	methods in MonoImages
	or 
search for
	methods in classes. 
    mono_method_desc_new
    
        
        
            
            Syntax
            MonoMethodDesc*
mono_method_desc_new (const char *name, gboolean include_namespace)
            
            Parameters
            | name | the method name. | 
| include_namespace | whether the name includes a namespace or not. | 
             Return value
             	 a parsed representation of the method description.
             Description
             
 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.
 
         
     
  
    mono_method_desc_free
    
        
        
            
            Syntax
            void
mono_method_desc_free (MonoMethodDesc *desc)
            
            Parameters
            | desc | method description to be released | 
             Description
             
 Releases the MonoMethodDesc object desc.
         
     
  
    mono_method_desc_from_method
    
        
        
            
            Syntax
            MonoMethodDesc*
mono_method_desc_from_method (MonoMethod *method)
            
         
     
  
    mono_method_desc_full_match
    
        
        
            
            Syntax
            gboolean
mono_method_desc_full_match (MonoMethodDesc *desc, MonoMethod *method)
            
            Parameters
            | desc | A method description that you created with mono_method_desc_new | 
| method | a MonoMethod instance that you want to match against | 
             Return value
             	 TRUE if the specified method matches the specified description, FALSE otherwise.
             Description
             
 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.
 
         
     
  
    mono_method_desc_match
    
        
        
            
            Syntax
            gboolean
mono_method_desc_match (MonoMethodDesc *desc, MonoMethod *method)
            
            Parameters
            | desc | MonoMethoDescription | 
| method | MonoMethodto test | 
             Return value
             	 TRUE if the method matches the description, FALSE otherwise.
             Description
             
 Determines whether the specified 
method matches the provided 
desc description.
 namespace and class are supposed to match already if this function is used.
 
         
     
  
    mono_method_desc_search_in_class
    
        
        
            
            Syntax
            MonoMethod*
mono_method_desc_search_in_class (MonoMethodDesc *desc, MonoClass *klass)
            
         
     
  
    mono_method_desc_search_in_image
    
        
        
            
            Syntax
            MonoMethod*
mono_method_desc_search_in_image (MonoMethodDesc *desc, MonoImage *image)
            
         
     
Working with Methods
  
    mono_method_full_name
    
        
        
            
            Syntax
            char*
mono_method_full_name (MonoMethod *method, gboolean signature)
            
         
     
  
    mono_method_get_class
    
        
        
            
            Syntax
            MonoClass*
mono_method_get_class (MonoMethod *method)
            
         
     
  
    mono_method_get_flags
    
        
        
            
            Syntax
            guint32
mono_method_get_flags (MonoMethod *method, guint32 *iflags)
            
         
     
  
    mono_method_get_last_managed
    
        
        
            
            Syntax
            MonoMethod*
mono_method_get_last_managed (void)
            
         
     
  
    mono_method_get_marshal_info
    
        
        
            
            Syntax
            void
mono_method_get_marshal_info (MonoMethod *method, MonoMarshalSpec **mspecs)
            
         
     
  
    mono_method_get_name
    
        
        
            
            Syntax
            const char*
mono_method_get_name (MonoMethod *method)
            
         
     
  
    mono_method_get_object
    
        
        
            
            Syntax
            MonoReflectionMethod*
mono_method_get_object (MonoDomain *domain, MonoMethod *method, MonoClass *refclass)
            
            Parameters
            | domain | an app domain | 
| method | a method | 
| refclass | the reflected type (can be NULL) | 
             Return value
             	 A System.Reflection.MonoMethod object representing the method method.
         
     
  
    mono_method_get_param_names
    
        
        
            
            Syntax
            void
mono_method_get_param_names (MonoMethod *method, const char **names)
            
         
     
  
    mono_method_get_param_token
    
        
        
            
            Syntax
            guint32
mono_method_get_param_token (MonoMethod *method, int index)
            
         
     
  
    mono_method_get_signature
    
        
        
            
            Syntax
            MonoMethodSignature*
mono_method_get_signature (MonoMethod *method, MonoImage *image, guint32 token)
            
             Description
             
 token is the method_ref/def/spec token used in a call IL instruction.
 \deprecated use the _checked variant
 Notes: runtime code MUST not use this function
         
     
  
    mono_method_get_index
    
        
        
            
            Syntax
            guint32
mono_method_get_index (MonoMethod *method)
            
             Description
             
 Find the method index in the metadata MethodDef table.
         
     
  
    mono_method_get_signature_full
    
        
        
            
            Syntax
            MonoMethodSignature*
mono_method_get_signature_full (MonoMethod *method, MonoImage *image, guint32 token, MonoGenericContext *context)
            
             Description
             
 token is the method ref/def/spec token used in a call IL instruction.
 \deprecated use the _checked variant
 Notes: runtime code MUST not use this function
         
     
  
    mono_method_get_token
    
        
        
            
            Syntax
            guint32
mono_method_get_token (MonoMethod *method)
            
         
     
  
    mono_method_get_unmanaged_thunk
    
        
        
            
            Syntax
            gpointer
mono_method_get_unmanaged_thunk (MonoMethod *method)
            
            Parameters
            | method | method to generate a thunk for. | 
             Description
             
 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.
 
         
     
  
    mono_method_has_marshal_info
    
        
        
            
            Syntax
            gboolean
mono_method_has_marshal_info (MonoMethod *method)
            
         
     
  
    mono_method_verify
    
        
        
            
            Syntax
            GSList*
mono_method_verify (MonoMethod *method, int level)
            
             Description
             
 Verify types for opcodes.
         
     
Invoking Methods
  
    mono_runtime_invoke
    
        
        
            
            Syntax
            MonoObject*
mono_runtime_invoke (MonoMethod *method, void *obj, void **params, MonoObject **exc)
            
            Parameters
            | method | method to invoke | 
| obj | object instance | 
| params | arguments to the method | 
| exc | exception information. | 
             Description
             
 Invokes the method represented by 
method on the object 
obj.
 
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.
 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.
 
     
If you want to invoke generic methods, you must call the method on the
"inflated" class, which you can obtain from the
mono_object_get_class()
MonoClass *clazz;
MonoMethod *method;
clazz = mono_object_get_class (obj);
/*
 * If there are more Add methods declared, you
 * may use mono_method_desc_search_in_class (clazz, ":Add(T)"),
 * you must substitute ":Add(T)" with the correct type, for example
 * for List<int>, you would use ":Add(int)".
 */
method = mono_class_get_method_from_name (clazz, "Add", 1);
mono_runtime_invoke (method, obj, args, &exception);
  
    mono_runtime_invoke_array
    
        
        
            
            Syntax
            MonoObject*
mono_runtime_invoke_array (MonoMethod *method, void *obj, MonoArray *params,
			   MonoObject **exc)
            
            Parameters
            | method | method to invoke | 
| obj | object instance | 
| params | arguments to the method | 
| exc | exception information. | 
             Description
             
 Invokes the method represented by 
method on the object 
obj.
 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.
 
     
  
    mono_runtime_delegate_invoke
    
        
        
            
            Syntax
            MonoObject*
mono_runtime_delegate_invoke (MonoObject *delegate, void **params, MonoObject **exc)
            
            Parameters
            | delegate | pointer to a delegate object. | 
| params | parameters for the delegate. | 
| exc | Pointer to the exception result. | 
             Description
             
 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.
 
         
     
  
    mono_method_body_get_object
    
        
        
            
            Syntax
            MonoReflectionMethodBody*
mono_method_body_get_object (MonoDomain *domain, MonoMethod *method)
            
            Parameters
            | domain | an app domain | 
| method | a method | 
             Return value
             	 A System.Reflection.MethodBody/RuntimeMethodBody object representing the method method.
         
     
Method Signatures
  
    mono_method_signature
    
        
        
            
            Syntax
            MonoMethodSignature*
mono_method_signature (MonoMethod *m)
            
             Return value
             	 the signature of the method m. On failure, returns NULL.
         
     
  
    mono_signature_explicit_this
    
        
        
            
            Syntax
            gboolean
mono_signature_explicit_this (MonoMethodSignature *sig)
            
            Parameters
            | sig | the method signature inspected | 
             Return value
             	 TRUE if this the method signature sig has an explicit
	 instance argument. FALSE otherwise.
         
     
  
    mono_signature_get_call_conv
    
        
        
            
            Syntax
            guint32
mono_signature_get_call_conv (MonoMethodSignature *sig)
            
            Parameters
            | sig | the method signature inspected | 
             Return value
             	 the call convention of the method signature sig.
         
     
  
    mono_signature_get_desc
    
        
        
            
            Syntax
            char*
mono_signature_get_desc (MonoMethodSignature *sig, gboolean include_namespace)
            
         
     
  
    mono_signature_get_param_count
    
        
        
            
            Syntax
            guint32
mono_signature_get_param_count (MonoMethodSignature *sig)
            
            Parameters
            | sig | the method signature inspected | 
             Return value
             	 the number of parameters in the method signature sig.
         
     
  
    mono_signature_get_params
    
        
        
            
            Syntax
            MonoType*
mono_signature_get_params (MonoMethodSignature *sig, gpointer *iter)
            
            Parameters
            | sig | the method signature inspected | 
| iter | pointer to an iterator | 
             Return value
             	 the next parameter type of the method signature sig,
	 NULL when finished.
             Description
             
 Iterates over the parameters for the method signature sig.
 A void* pointer must be initialized to NULL to start the iteration
 and its address is passed to this function repeteadly until it returns
 NULL.
         
     
  
    mono_signature_get_return_type
    
        
        
            
            Syntax
            MonoType*
mono_signature_get_return_type (MonoMethodSignature *sig)
            
            Parameters
            | sig | the method signature inspected | 
             Return value
             	 the return type of the method signature sig
         
     
  
    mono_signature_hash
    
        
        
            
            Syntax
            guint
mono_signature_hash (MonoMethodSignature *sig)
            
         
     
  
    mono_signature_is_instance
    
        
        
            
            Syntax
            gboolean
mono_signature_is_instance (MonoMethodSignature *sig)
            
            Parameters
            | sig | the method signature inspected | 
             Return value
             	 TRUE if this the method signature sig has an implicit
	 first instance argument. FALSE otherwise.
         
     
  
    mono_signature_param_is_out
    
        
        
            
            Syntax
            mono_bool
mono_signature_param_is_out (MonoMethodSignature *sig, int param_num)
            
            Parameters
            | sig | the method signature inspected | 
| param_num | the 0-based index of the inspected parameter | 
             Return value
             	 TRUE if the parameter is an out parameter, FALSE
	 otherwise.
         
     
  
    mono_signature_vararg_start
    
        
        
            
            Syntax
            int
mono_signature_vararg_start (MonoMethodSignature *sig)
            
            Parameters
            | sig | the method signature inspected | 
             Return value
             	 the number of the first vararg parameter in the
	 method signature \param sig. -1 if this is not a vararg signature.
         
     
  
    mono_param_get_objects
    
        
        
            
            Syntax
            MonoArray*
mono_param_get_objects (MonoDomain *domain, MonoMethod *method)
            
         
     
  
    mono_get_method_full
    
        
        
            
            Syntax
            MonoMethod*
mono_get_method_full (MonoImage *image, guint32 token, MonoClass *klass,
		      MonoGenericContext *context)
            
         
     
  
    mono_get_method
    
        
        
            
            Syntax
            MonoMethod*
mono_get_method (MonoImage *image, guint32 token, MonoClass *klass)
            
         
     
Methods Header Operations
  
    mono_method_get_header
    
        
        
            
            Syntax
            MonoMethodHeader*
mono_method_get_header (MonoMethod *method)
            
         
     
  
    mono_method_header_get_clauses
    
        
        
            
            Syntax
            int
mono_method_header_get_clauses (MonoMethodHeader *header, MonoMethod *method, gpointer *iter, MonoExceptionClause *clause)
            
            Parameters
            | header | a MonoMethodHeaderpointer | 
| method | MonoMethodthe header belongs to | 
| iter | pointer to a iterator | 
| clause | pointer to a MonoExceptionClausestructure which will be filled with the info | 
             Return value
             	 TRUE if clause was filled with info, FALSE if there are no more exception
	 clauses.
             Description
             
 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.
 
         
     
  
    mono_method_header_get_code
    
        
        
            
            Syntax
            const unsigned char*
mono_method_header_get_code (MonoMethodHeader *header, guint32* code_size, guint32* max_stack)
            
            Parameters
            | header | a MonoMethodHeaderpointer | 
| code_size | memory location for returning the code size | 
| max_stack | memory location for returning the max stack | 
             Return value
             	 pointer to the IL code represented by the method header.
             Description
             
 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.
 
         
     
  
    mono_method_header_get_locals
    
        
        
            
            Syntax
            MonoType*
mono_method_header_get_locals (MonoMethodHeader *header, guint32* num_locals, gboolean *init_locals)
            
            Parameters
            | header | a MonoMethodHeaderpointer | 
| num_locals | memory location for returning the number of local variables | 
| init_locals | memory location for returning the init_locals flag | 
             Return value
             	 pointer to an array of types of the local variables
             Description
             
 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