1 #include <mono/jit/jit.h>
2 #include <mono/metadata/object.h>
3 #include <mono/metadata/environment.h>
4 #include <mono/metadata/assembly.h>
5 #include <mono/metadata/debug-helpers.h>
11 * Simple mono embedding example.
12 * We show how to create objects and invoke methods and set fields in them.
14 * gcc -Wall -o test-invoke test-invoke.c `pkg-config --cflags --libs mono-2` -lm
17 * ./test-invoke invoke.exe
21 access_valuetype_field (MonoObject
*obj
)
24 MonoClassField
*field
;
27 klass
= mono_object_get_class (obj
);
29 /* Now we'll change the value of the 'val' field (see invoke.cs) */
30 field
= mono_class_get_field_from_name (klass
, "val");
32 /* This time we also add a bit of error checking... */
34 fprintf (stderr
, "Can't find field val in MyType\n");
37 /* Check that val is an int (if you're paranoid or if you need to
38 * show how this API is used)
40 if (mono_type_get_type (mono_field_get_type (field
)) != MONO_TYPE_I4
) {
41 fprintf (stderr
, "Field val is not a 32 bit integer\n");
45 /* Note we pass a pointer to the value */
46 mono_field_get_value (obj
, field
, &val
);
47 printf ("Value of field is: %d\n", val
);
50 /* Note we pass a pointer to the value here as well */
51 mono_field_set_value (obj
, field
, &val
);
56 access_reference_field (MonoObject
*obj
)
64 klass
= mono_object_get_class (obj
);
65 domain
= mono_object_get_domain (obj
);
67 /* Now we'll see that a reference type is handled slightly differently.
68 * First, get the MonoClassField representing it.
70 str
= mono_class_get_field_from_name (klass
, "str");
72 /* No change here, we always pass a pointer */
73 mono_field_get_value (obj
, str
, &strval
);
75 /* get the string in UTF-8 encoding to print it */
76 p
= mono_string_to_utf8 (strval
);
77 printf ("Value of str is: %s\n", p
);
78 /* we need to free the result from mono_string_to_utf8 () */
81 /* string are immutable, so we need to create a different string */
82 strval
= mono_string_new (domain
, "hello from the embedding API");
84 /* Here is the slight difference: for reference types we pass
85 * the pointer directly, instead of a pointer to the value.
87 mono_field_set_value (obj
, str
, strval
);
91 /* Demostrate how to call methods */
93 call_methods (MonoObject
*obj
)
97 MonoMethod
*method
= NULL
, *m
= NULL
, *ctor
= NULL
, *fail
= NULL
, *mvalues
;
99 MonoObject
*result
, *exception
;
106 klass
= mono_object_get_class (obj
);
107 domain
= mono_object_get_domain (obj
);
109 /* retrieve all the methods we need */
111 while ((m
= mono_class_get_methods (klass
, &iter
))) {
112 if (strcmp (mono_method_get_name (m
), "method") == 0) {
114 } else if (strcmp (mono_method_get_name (m
), "Fail") == 0) {
116 } else if (strcmp (mono_method_get_name (m
), "Values") == 0) {
118 } else if (strcmp (mono_method_get_name (m
), ".ctor") == 0) {
119 /* Check it's the ctor that takes two args:
120 * as you see a contrsuctor is a method like any other.
122 MonoMethodSignature
* sig
= mono_method_signature (m
);
123 if (mono_signature_get_param_count (sig
) == 2) {
128 /* Now we'll call method () on obj: since it takes no arguments
129 * we can pass NULL as the third argument to mono_runtime_invoke ().
130 * The method will print the updated value.
132 mono_runtime_invoke (method
, obj
, NULL
, NULL
);
134 /* mono_object_new () doesn't call any constructor: this means that
135 * we'll have to invoke the constructor if needed ourselves. Note:
136 * invoking a constructor is no different than calling any other method,
137 * so we'll still call mono_runtime_invoke (). This also means that we
138 * can invoke a constructor at any time, like now.
139 * First, setup the array of arguments and their values.
142 /* As usual, we use the address of the data for valuetype arguments */
145 /* and the pointer for reference types: mono_array_new () returns a MonoArray* */
146 args
[1] = mono_array_new (domain
, mono_get_byte_class (), 256);
147 mono_runtime_invoke (ctor
, obj
, args
, NULL
);
149 /* A property exists only as a metadata entity, so getting or setting the value
150 * is nothing more than calling mono_runtime_invoke () on the getter or setter method.
152 prop
= mono_class_get_property_from_name (klass
, "Value");
153 method
= mono_property_get_get_method (prop
);
154 result
= mono_runtime_invoke (method
, obj
, NULL
, NULL
);
155 /* mono_runtime_invoke () always boxes the return value if it's a valuetype */
156 val
= *(int*)mono_object_unbox (result
);
158 printf ("Value of val from property is: %d\n", val
);
160 /* we also have an helper method: note that reference types are returned as is */
161 prop
= mono_class_get_property_from_name (klass
, "Message");
162 str
= (MonoString
*)mono_property_get_value (prop
, obj
, NULL
, NULL
);
163 /* get the string in UTF-8 encoding to print it */
164 p
= mono_string_to_utf8 (str
);
165 printf ("Value of str from property is: %s\n", p
);
166 /* we need to free the result from mono_string_to_utf8 () */
169 /* Now we'll show two things:
170 * 1) static methods are invoked with mono_runtime_invoke () as well,
171 * we just pass NULL as the second argument.
172 * 2) we can catch exceptions thrown by the called method.
173 * Note: fail is declared as static void Fail () in invoke.cs.
174 * We first set result to NULL: if after the invocation it will have
175 * a different value, it will be the exception that was thrown from
176 * the Fail () method. Note that if an exception was thrown, the return
177 * value (if any) is undefined and can't be used in any way (yes, the above
178 * invocations don't have this type of error checking to make things simpler).
181 mono_runtime_invoke (fail
, NULL
, NULL
, &exception
);
183 printf ("An exception was thrown in Fail ()\n");
186 /* Now let's see how to handle methods that take by ref arguments:
187 * Valuetypes continue to be passed as pointers to the data.
188 * Reference arguments passed by ref (ref or out is the same)
189 * are handled the same way: a pointer to the pointer is used
190 * (so that the result can be read back).
191 * Small note: in this case (a System.Int32 valuetype) we can just
192 * use &val where val is a C 32 bit integer. In the general case
193 * unmanaged code doesn't know the size of a valuetype, since the
194 * runtime may decide to lay it out in what it thinks is a better way
195 * (unless ExplicitLayout is set). To avoid issues, the best thing is to
196 * create an object of the valuetype's class and retrieve the pointer
197 * to the data with the mono_object_unbox () function.
200 str
= mono_string_new (domain
, "another string");
203 mono_runtime_invoke (mvalues
, obj
, args
, NULL
);
204 /* get the string in UTF-8 encoding to print it */
205 p
= mono_string_to_utf8 (str
);
206 printf ("Values of str/val from Values () are: %s/%d\n", p
, val
);
207 /* we need to free the result from mono_string_to_utf8 () */
212 more_methods (MonoDomain
*domain
)
215 MonoMethodDesc
* mdesc
;
216 MonoMethod
*method
, *vtmethod
;
222 /* Now let's call an instance method on a valuetype. There are two
224 * 1) calling a virtual method defined in a base class, like ToString ():
225 * we need to pass the value boxed in an object
226 * 2) calling a normal instance method: in this case
227 * we pass the address to the valuetype as the second argument
228 * instead of an object.
229 * First some initialization.
232 klass
= mono_get_int32_class ();
233 obj
= mono_value_box (domain
, klass
, &val
);
235 /* A different way to search for a method */
236 mdesc
= mono_method_desc_new (":ToString()", FALSE
);
237 vtmethod
= mono_method_desc_search_in_class (mdesc
, klass
);
239 str
= (MonoString
*)mono_runtime_invoke (vtmethod
, &val
, NULL
, NULL
);
240 /* get the string in UTF-8 encoding to print it */
241 p
= mono_string_to_utf8 (str
);
242 printf ("25.ToString (): %s\n", p
);
243 /* we need to free the result from mono_string_to_utf8 () */
246 /* Now: see how the result is different if we search for the ToString ()
247 * method in System.Object: mono_runtime_invoke () doesn't do any sort of
248 * virtual method invocation: it calls the exact method that it was given
249 * to execute. If a virtual call is needed, mono_object_get_virtual_method ()
252 method
= mono_method_desc_search_in_class (mdesc
, mono_get_object_class ());
253 str
= (MonoString
*)mono_runtime_invoke (method
, obj
, NULL
, NULL
);
254 /* get the string in UTF-8 encoding to print it */
255 p
= mono_string_to_utf8 (str
);
256 printf ("25.ToString (), from System.Object: %s\n", p
);
257 /* we need to free the result from mono_string_to_utf8 () */
260 /* Now get the method that overrides ToString () in obj */
261 vtmethod
= mono_object_get_virtual_method (obj
, method
);
262 if (mono_class_is_valuetype (mono_method_get_class (vtmethod
))) {
263 printf ("Need to unbox this for call to virtual ToString () for %s\n", mono_class_get_name (klass
));
266 mono_method_desc_free (mdesc
);
270 create_object (MonoDomain
*domain
, MonoImage
*image
)
275 klass
= mono_class_from_name (image
, "Embed", "MyType");
277 fprintf (stderr
, "Can't find MyType in assembly %s\n", mono_image_get_filename (image
));
281 obj
= mono_object_new (domain
, klass
);
282 /* mono_object_new () only allocates the storage:
283 * it doesn't run any constructor. Tell the runtime to run
284 * the default argumentless constructor.
286 mono_runtime_object_init (obj
);
288 access_valuetype_field (obj
);
289 access_reference_field (obj
);
292 more_methods (domain
);
295 static void main_function (MonoDomain
*domain
, const char *file
, int argc
, char **argv
)
297 MonoAssembly
*assembly
;
299 /* Loading an assembly makes the runtime setup everything
300 * needed to execute it. If we're just interested in the metadata
301 * we'd use mono_image_load (), instead and we'd get a MonoImage*.
303 assembly
= mono_domain_assembly_open (domain
, file
);
307 * mono_jit_exec() will run the Main() method in the assembly.
308 * The return value needs to be looked up from
309 * System.Environment.ExitCode.
311 mono_jit_exec (domain
, assembly
, argc
, argv
);
313 create_object (domain
, mono_assembly_get_image (assembly
));
317 main (int argc
, char* argv
[]) {
323 fprintf (stderr
, "Please provide an assembly to load\n");
328 * mono_jit_init() creates a domain: each assembly is
329 * loaded and run in a MonoDomain.
331 domain
= mono_jit_init (file
);
333 main_function (domain
, file
, argc
- 1, argv
+ 1);
335 retval
= mono_environment_exitcode_get ();
337 mono_jit_cleanup (domain
);