?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Reflect shared code changes
[mono-project.git] / mcs / class / System.Private.CoreLib / System / Delegate.cs
blob71972044ac83fd03342712e4f047c535f37fdadf
1 using System.Reflection;
2 using System.Runtime.CompilerServices;
3 using System.Runtime.InteropServices;
4 using System.Runtime.Serialization;
5
6 namespace System
7 {
8 /* Contains the rarely used fields of Delegate */
9 sealed class DelegateData
10 {
11 public Type target_type;
12 public string method_name;
13 public bool curried_first_arg;
14 }
15
16 [StructLayout (LayoutKind.Sequential)]
17 partial class Delegate
18 {
19 #region Sync with object-internals.h
20 IntPtr method_ptr;
21 IntPtr invoke_impl;
22 object _target;
23 IntPtr method;
24 IntPtr delegate_trampoline;
25 IntPtr extra_arg;
26 IntPtr method_code;
27 IntPtr interp_method;
28 IntPtr interp_invoke_impl;
29 MethodInfo method_info;
30
31 // Keep a ref of the MethodInfo passed to CreateDelegate.
32 // Used to keep DynamicMethods alive.
33 MethodInfo original_method_info;
34
35 DelegateData data;
36
37 bool method_is_virtual;
38 #endregion
39
40 protected Delegate (object target, string method)
41 {
42 if (target == null)
43 throw new ArgumentNullException (nameof(target));
44
45 if (method == null)
46 throw new ArgumentNullException (nameof(method));
47
48 this._target = target;
49 this.data = new DelegateData () {
50 method_name = method
51 };
52 }
53
54 protected Delegate (Type target, string method)
55 {
56 if (target == null)
57 throw new ArgumentNullException (nameof (target));
58
59 if (target.ContainsGenericParameters)
60 throw new ArgumentException (SR.Arg_UnboundGenParam, nameof (target));
61
62 if (method == null)
63 throw new ArgumentNullException (nameof (method));
64
65 if (!target.IsRuntimeImplemented ())
66 throw new ArgumentException (SR.Argument_MustBeRuntimeType, nameof (target));
67
68 this.data = new DelegateData () {
69 method_name = method,
70 target_type = target
71 };
72 }
73
74 public object Target => _target;
75
76 public static Delegate CreateDelegate (Type type, object firstArgument, MethodInfo method, bool throwOnBindFailure)
77 {
78 return CreateDelegate (type, firstArgument, method, throwOnBindFailure, true);
79 }
80
81 public static Delegate CreateDelegate (Type type, MethodInfo method, bool throwOnBindFailure)
82 {
83 return CreateDelegate (type, null, method, throwOnBindFailure, false);
84 }
85
86 static Delegate CreateDelegate (Type type, object firstArgument, MethodInfo method, bool throwOnBindFailure, bool allowClosed)
87 {
88 if (type == null)
89 throw new ArgumentNullException (nameof (type));
90 if (method == null)
91 throw new ArgumentNullException (nameof (method));
92
93 RuntimeType rtType = type as RuntimeType;
94 if (rtType == null)
95 throw new ArgumentException (SR.Argument_MustBeRuntimeType, nameof (type));
96 if (!(method is RuntimeMethodInfo || method is System.Reflection.Emit.DynamicMethod))
97 throw new ArgumentException (SR.Argument_MustBeRuntimeMethodInfo, nameof (method));
98
99 if (!rtType.IsDelegate ())
100 throw new ArgumentException (SR.Arg_MustBeDelegate, nameof (type));
101
102 if (!IsMatchingCandidate (type, firstArgument, method, allowClosed, out DelegateData delegate_data)) {
103 if (throwOnBindFailure)
104 throw new ArgumentException (SR.Arg_DlgtTargMeth);
105
106 return null;
107 }
108
109 Delegate d = CreateDelegate_internal (type, firstArgument, method, throwOnBindFailure);
110 if (d != null)
111 d.original_method_info = method;
112 if (delegate_data != null)
113 d.data = delegate_data;
114 return d;
115 }
116
117 public static Delegate CreateDelegate (Type type, object target, string method, bool ignoreCase, bool throwOnBindFailure)
118 {
119 if (type == null)
120 throw new ArgumentNullException (nameof (type));
121 if (target == null)
122 throw new ArgumentNullException (nameof (target));
123 if (method == null)
124 throw new ArgumentNullException (nameof (method));
125
126 RuntimeType rtType = type as RuntimeType;
127 if (rtType == null)
128 throw new ArgumentException (SR.Argument_MustBeRuntimeType, nameof (type));
129 if (!rtType.IsDelegate ())
130 throw new ArgumentException (SR.Arg_MustBeDelegate, nameof (type));
131
132 MethodInfo info = GetCandidateMethod (type, target.GetType (), method, BindingFlags.Instance, ignoreCase);
133 if (info == null) {
134 if (throwOnBindFailure)
135 throw new ArgumentException (SR.Arg_DlgtTargMeth);
136
137 return null;
138 }
139
140 return CreateDelegate_internal (type, null, info, throwOnBindFailure);
141 }
142
143 public static Delegate CreateDelegate (Type type, Type target, string method, bool ignoreCase, bool throwOnBindFailure)
144 {
145 if (type == null)
146 throw new ArgumentNullException (nameof (type));
147 if (target == null)
148 throw new ArgumentNullException (nameof (target));
149 if (target.ContainsGenericParameters)
150 throw new ArgumentException (SR.Arg_UnboundGenParam, nameof (target));
151 if (method == null)
152 throw new ArgumentNullException (nameof (method));
153
154 RuntimeType rtType = type as RuntimeType;
155 RuntimeType rtTarget = target as RuntimeType;
156 if (rtType == null)
157 throw new ArgumentException (SR.Argument_MustBeRuntimeType, nameof (type));
158 if (rtTarget == null)
159 throw new ArgumentException (SR.Argument_MustBeRuntimeType, nameof (target));
160 if (!rtType.IsDelegate ())
161 throw new ArgumentException (SR.Arg_MustBeDelegate, nameof (type));
162
163 MethodInfo info = GetCandidateMethod (type, target, method, BindingFlags.Static, ignoreCase);
164 if (info == null) {
165 if (throwOnBindFailure)
166 throw new ArgumentException (SR.Arg_DlgtTargMeth);
167
168 return null;
169 }
170
171 return CreateDelegate_internal (type, null, info, throwOnBindFailure);
172 }
173
174 static MethodInfo GetCandidateMethod (Type type, Type target, string method, BindingFlags bflags, bool ignoreCase)
175 {
176 MethodInfo invoke = type.GetMethod ("Invoke");
177 ParameterInfo [] delargs = invoke.GetParametersInternal ();
178 Type[] delargtypes = new Type [delargs.Length];
179
180 for (int i = 0; i < delargs.Length; i++)
181 delargtypes [i] = delargs [i].ParameterType;
182
183 /*
184 * since we need to walk the inheritance chain anyway to
185 * find private methods, adjust the bindingflags to ignore
186 * inherited methods
187 */
188 BindingFlags flags = BindingFlags.ExactBinding |
189 BindingFlags.Public | BindingFlags.NonPublic |
190 BindingFlags.DeclaredOnly | bflags;
191
192 if (ignoreCase)
193 flags |= BindingFlags.IgnoreCase;
194
195 MethodInfo info = null;
196
197 for (Type targetType = target; targetType != null; targetType = targetType.BaseType) {
198 MethodInfo mi = targetType.GetMethod (method, flags,
199 null, delargtypes, Array.Empty<ParameterModifier>());
200 if (mi != null && IsReturnTypeMatch (invoke.ReturnType, mi.ReturnType)) {
201 info = mi;
202 break;
203 }
204 }
205
206 return info;
207 }
208
209 static bool IsMatchingCandidate (Type type, object target, MethodInfo method, bool allowClosed, out DelegateData delegate_data)
210 {
211 MethodInfo invoke = type.GetMethod ("Invoke");
212
213 if (!IsReturnTypeMatch (invoke.ReturnType, method.ReturnType)) {
214 delegate_data = null;
215 return false;
216 }
217
218 ParameterInfo[] delargs = invoke.GetParametersInternal ();
219 ParameterInfo[] args = method.GetParametersInternal ();
220
221 bool argLengthMatch;
222
223 if (target != null) {
224 // delegate closed over target
225 if (!method.IsStatic)
226 // target is passed as this
227 argLengthMatch = (args.Length == delargs.Length);
228 else
229 // target is passed as the first argument to the static method
230 argLengthMatch = (args.Length == delargs.Length + 1);
231 } else {
232 if (!method.IsStatic) {
233 //
234 // Net 2.0 feature. The first argument of the delegate is passed
235 // as the 'this' argument to the method.
236 //
237 argLengthMatch = (args.Length + 1 == delargs.Length);
238
239 if (!argLengthMatch)
240 // closed over a null reference
241 argLengthMatch = (args.Length == delargs.Length);
242 } else {
243 argLengthMatch = (args.Length == delargs.Length);
244
245 if (!argLengthMatch)
246 // closed over a null reference
247 argLengthMatch = args.Length == delargs.Length + 1;
248 }
249 }
250
251 if (!argLengthMatch) {
252 delegate_data = null;
253 return false;
254 }
255
256 bool argsMatch;
257 delegate_data = new DelegateData ();
258
259 if (target != null) {
260 if (!method.IsStatic) {
261 argsMatch = IsArgumentTypeMatchWithThis (target.GetType (), method.DeclaringType, true);
262 for (int i = 0; i < args.Length; i++)
263 argsMatch &= IsArgumentTypeMatch (delargs [i].ParameterType, args [i].ParameterType);
264 } else {
265 argsMatch = IsArgumentTypeMatch (target.GetType (), args [0].ParameterType);
266 for (int i = 1; i < args.Length; i++)
267 argsMatch &= IsArgumentTypeMatch (delargs [i - 1].ParameterType, args [i].ParameterType);
268
269 delegate_data.curried_first_arg = true;
270 }
271 } else {
272 if (!method.IsStatic) {
273 if (args.Length + 1 == delargs.Length) {
274 // The first argument should match this
275 argsMatch = IsArgumentTypeMatchWithThis (delargs [0].ParameterType, method.DeclaringType, false);
276 for (int i = 0; i < args.Length; i++)
277 argsMatch &= IsArgumentTypeMatch (delargs [i + 1].ParameterType, args [i].ParameterType);
278 } else {
279 // closed over a null reference
280 argsMatch = allowClosed;
281 for (int i = 0; i < args.Length; i++)
282 argsMatch &= IsArgumentTypeMatch (delargs [i].ParameterType, args [i].ParameterType);
283 }
284 } else {
285 if (delargs.Length + 1 == args.Length) {
286 // closed over a null reference
287 argsMatch = !(args [0].ParameterType.IsValueType || args [0].ParameterType.IsByRef) && allowClosed;
288 for (int i = 0; i < delargs.Length; i++)
289 argsMatch &= IsArgumentTypeMatch (delargs [i].ParameterType, args [i + 1].ParameterType);
290
291 delegate_data.curried_first_arg = true;
292 } else {
293 argsMatch = true;
294 for (int i = 0; i < args.Length; i++)
295 argsMatch &= IsArgumentTypeMatch (delargs [i].ParameterType, args [i].ParameterType);
296 }
297 }
298 }
299
300 return argsMatch;
301 }
302
303 static bool IsReturnTypeMatch (Type delReturnType, Type returnType)
304 {
305 bool returnMatch = returnType == delReturnType;
306
307 if (!returnMatch) {
308 // Delegate covariance
309 if (!returnType.IsValueType && delReturnType.IsAssignableFrom (returnType))
310 returnMatch = true;
311 }
312
313 return returnMatch;
314 }
315
316 static bool IsArgumentTypeMatch (Type delArgType, Type argType)
317 {
318 bool match = delArgType == argType;
319
320 // Delegate contravariance
321 if (!match) {
322 if (!argType.IsValueType && argType.IsAssignableFrom (delArgType))
323 match = true;
324 }
325 // enum basetypes
326 if (!match) {
327 if (delArgType.IsEnum && Enum.GetUnderlyingType (delArgType) == argType)
328 match = true;
329 else if (argType.IsEnum && Enum.GetUnderlyingType (argType) == delArgType)
330 match = true;
331 }
332
333 return match;
334 }
335
336 static bool IsArgumentTypeMatchWithThis (Type delArgType, Type argType, bool boxedThis)
337 {
338 bool match;
339 if (argType.IsValueType)
340 match = delArgType.IsByRef && delArgType.GetElementType () == argType ||
341 (boxedThis && delArgType == argType);
342 else
343 match = delArgType == argType || argType.IsAssignableFrom (delArgType);
344
345 return match;
346 }
347
348 protected virtual object DynamicInvokeImpl (object[] args)
349 {
350 if (Method == null) {
351 Type[] mtypes = new Type [args.Length];
352 for (int i = 0; i < args.Length; ++i) {
353 mtypes [i] = args [i].GetType ();
354 }
355 method_info = _target.GetType ().GetMethod (data.method_name, mtypes);
356 }
357
358 var target = _target;
359 if (this.data == null)
360 InitializeDelegateData ();
361
362 if (Method.IsStatic) {
363 //
364 // The delegate is bound to _target
365 //
366 if (data.curried_first_arg) {
367 if (args == null) {
368 args = new [] { target };
369 } else {
370 Array.Resize (ref args, args.Length + 1);
371 Array.Copy (args, 0, args, 1, args.Length - 1);
372 args [0] = target;
373 }
374
375 target = null;
376 }
377 } else {
378 if (_target == null && args != null && args.Length > 0) {
379 target = args [0];
380 Array.Copy (args, 1, args, 0, args.Length - 1);
381 Array.Resize (ref args, args.Length - 1);
382 }
383 }
384
385 return Method.Invoke (target, args);
386 }
387
388 public override bool Equals (object obj)
389 {
390 Delegate d = obj as Delegate;
391
392 if (d == null)
393 return false;
394
395 // Do not compare method_ptr, since it can point to a trampoline
396 if (d._target == _target && d.Method == Method) {
397 if (d.data != null || data != null) {
398 /* Uncommon case */
399 if (d.data != null && data != null)
400 return (d.data.target_type == data.target_type && d.data.method_name == data.method_name);
401 else {
402 if (d.data != null)
403 return d.data.target_type == null;
404 if (data != null)
405 return data.target_type == null;
406 return false;
407 }
408 }
409 return true;
410 }
411
412 return false;
413 }
414
415 public override int GetHashCode ()
416 {
417 MethodInfo m = Method;
418
419 return (m != null ? m.GetHashCode () : GetType ().GetHashCode ()) ^ RuntimeHelpers.GetHashCode (_target);
420 }
421
422 protected virtual MethodInfo GetMethodImpl ()
423 {
424 if (method_info != null)
425 return method_info;
426
427 if (method != IntPtr.Zero) {
428 if (!method_is_virtual)
429 method_info = (MethodInfo) RuntimeMethodInfo.GetMethodFromHandleNoGenericCheck (new RuntimeMethodHandle (method));
430 else
431 method_info = GetVirtualMethod_internal ();
432 }
433
434 return method_info;
435 }
436
437 void InitializeDelegateData ()
438 {
439 DelegateData delegate_data = new DelegateData ();
440 if (method_info.IsStatic) {
441 if (_target != null) {
442 delegate_data.curried_first_arg = true;
443 } else {
444 MethodInfo invoke = GetType ().GetMethod ("Invoke");
445 if (invoke.GetParametersCount () + 1 == method_info.GetParametersCount ())
446 delegate_data.curried_first_arg = true;
447 }
448 }
449 this.data = delegate_data;
450 }
451
452 static bool InternalEqualTypes (object source, object value)
453 {
454 return source.GetType () == value.GetType ();
455 }
456
457 [MethodImplAttribute (MethodImplOptions.InternalCall)]
458 private protected extern static MulticastDelegate AllocDelegateLike_internal (Delegate d);
459
460 [MethodImplAttribute (MethodImplOptions.InternalCall)]
461 static extern Delegate CreateDelegate_internal (Type type, object target, MethodInfo info, bool throwOnBindFailure);
462
463 [MethodImplAttribute (MethodImplOptions.InternalCall)]
464 extern MethodInfo GetVirtualMethod_internal ();
465 }
466 }
Mirror of the official Mono project git repository