1 // System.Reflection.Binder
4 // Sean MacIsaac (macisaac@ximian.com)
5 // Paolo Molaro (lupus@ximian.com)
6 // Gonzalo Paniagua Javier (gonzalo@ximian.com)
8 // (C) Ximian, Inc. 2001 - 2003
9 // (c) Copyright 2004 Novell, Inc. (http://www.novell.com)
12 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
14 // Permission is hereby granted, free of charge, to any person obtaining
15 // a copy of this software and associated documentation files (the
16 // "Software"), to deal in the Software without restriction, including
17 // without limitation the rights to use, copy, modify, merge, publish,
18 // distribute, sublicense, and/or sell copies of the Software, and to
19 // permit persons to whom the Software is furnished to do so, subject to
20 // the following conditions:
22 // The above copyright notice and this permission notice shall be
23 // included in all copies or substantial portions of the Software.
25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
29 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
30 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
31 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
34 using System.Globalization;
35 using System.Runtime.InteropServices;
37 namespace System.Reflection
43 [ClassInterface(ClassInterfaceType.AutoDual)]
44 public abstract class Binder
46 protected Binder () {}
48 public abstract FieldInfo BindToField (BindingFlags bindingAttr, FieldInfo[] match, object value, CultureInfo culture);
49 public abstract MethodBase BindToMethod (BindingFlags bindingAttr, MethodBase[] match, ref object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] names, out object state);
50 public abstract object ChangeType (object value, Type type, CultureInfo culture);
51 public abstract void ReorderArgumentArray( ref object[] args, object state);
52 public abstract MethodBase SelectMethod (BindingFlags bindingAttr, MethodBase[] match, Type[] types, ParameterModifier[] modifiers);
53 public abstract PropertyInfo SelectProperty( BindingFlags bindingAttr, PropertyInfo[] match, Type returnType, Type[] indexes, ParameterModifier[] modifiers);
55 static Binder default_binder = new Default ();
57 internal static Binder DefaultBinder {
59 return default_binder;
63 internal static bool ConvertArgs (Binder binder, object[] args, ParameterInfo[] pinfo, CultureInfo culture) {
65 if ( pinfo.Length == 0)
68 throw new TargetParameterCountException ();
70 if (pinfo.Length != args.Length)
71 throw new TargetParameterCountException ();
72 for (int i = 0; i < args.Length; ++i) {
73 object v = binder.ChangeType (args [i], pinfo[i].ParameterType, culture);
74 if ((v == null) && (args [i] != null))
81 internal static int GetDerivedLevel (Type type)
83 Type searchType = type;
86 while (searchType.BaseType != null)
89 searchType = searchType.BaseType;
95 internal static MethodBase FindMostDerivedMatch (MethodBase [] match)
99 int count = match.Length;
101 for (int current = 0; current < count; current++)
103 int level = GetDerivedLevel (match[current].DeclaringType);
104 if (level == highLevel)
105 throw new AmbiguousMatchException ();
107 if (level > highLevel)
114 return match[matchId];
117 internal sealed class Default : Binder {
118 public override FieldInfo BindToField (BindingFlags bindingAttr, FieldInfo[] match, object value, CultureInfo culture)
121 throw new ArgumentNullException ("match");
122 foreach (FieldInfo f in match) {
123 if (check_type (value.GetType (), f.FieldType))
130 // FIXME: There was a MonoTODO, but it does not explain what the problem is
132 public override MethodBase BindToMethod (BindingFlags bindingAttr, MethodBase[] match, ref object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] names, out object state)
136 types = Type.EmptyTypes;
138 types = new Type [args.Length];
139 for (int i = 0; i < args.Length; ++i) {
140 if (args [i] != null)
141 types [i] = args [i].GetType ();
144 MethodBase selected = SelectMethod (bindingAttr, match, types, modifiers);
147 ReorderParameters (names, ref args, selected);
151 void ReorderParameters (string [] names, ref object [] args, MethodBase selected)
153 object [] newArgs = new object [args.Length];
154 Array.Copy (args, newArgs, args.Length);
155 ParameterInfo [] plist = selected.GetParameters ();
156 for (int n = 0; n < names.Length; n++)
157 for (int p = 0; p < plist.Length; p++) {
158 if (names [n] == plist [p].Name) {
159 newArgs [p] = args [n];
163 Array.Copy (newArgs, args, args.Length);
166 static bool IsArrayAssignable (Type object_type, Type target_type)
168 if (object_type.IsArray && target_type.IsArray)
169 return IsArrayAssignable (object_type.GetElementType (), target_type.GetElementType ());
171 if (target_type.IsAssignableFrom (object_type))
177 public override object ChangeType (object value, Type type, CultureInfo culture)
181 Type vtype = value.GetType ();
183 type = type.GetElementType ();
184 if (vtype == type || type.IsInstanceOfType (value))
186 if (vtype.IsArray && type.IsArray){
187 if (IsArrayAssignable (vtype.GetElementType (), type.GetElementType ()))
191 if (check_type (vtype, type))
192 return Convert.ChangeType (value, type);
196 [MonoTODO ("This method does not do anything in Mono")]
197 public override void ReorderArgumentArray (ref object[] args, object state)
199 //do nothing until we support named arguments
200 //throw new NotImplementedException ();
203 private static bool check_type (Type from, Type to) {
210 TypeCode fromt = Type.GetTypeCode (from);
211 TypeCode tot = Type.GetTypeCode (to);
213 if (to.IsByRef != from.IsByRef)
217 return to.IsAssignableFrom (from);
222 case TypeCode.UInt16:
223 case TypeCode.UInt32:
225 case TypeCode.UInt64:
227 case TypeCode.Single:
228 case TypeCode.Double:
231 return to == typeof (object);
235 case TypeCode.UInt16:
237 case TypeCode.UInt32:
239 case TypeCode.UInt64:
241 case TypeCode.Single:
242 case TypeCode.Double:
245 return to == typeof (object) || (from.IsEnum && to == typeof (Enum));
251 case TypeCode.Single:
252 case TypeCode.Double:
255 return to == typeof (object) || (from.IsEnum && to == typeof (Enum));
256 case TypeCode.UInt16:
258 case TypeCode.UInt32:
260 case TypeCode.UInt64:
262 case TypeCode.Single:
263 case TypeCode.Double:
266 return to == typeof (object) || (from.IsEnum && to == typeof (Enum));
271 case TypeCode.Single:
272 case TypeCode.Double:
275 return to == typeof (object) || (from.IsEnum && to == typeof (Enum));
276 case TypeCode.UInt32:
278 case TypeCode.UInt64:
280 case TypeCode.Single:
281 case TypeCode.Double:
284 return to == typeof (object) || (from.IsEnum && to == typeof (Enum));
288 case TypeCode.Single:
289 case TypeCode.Double:
292 return to == typeof (object) || (from.IsEnum && to == typeof (Enum));
293 case TypeCode.UInt64:
296 case TypeCode.Single:
297 case TypeCode.Double:
300 return to == typeof (object) || (from.IsEnum && to == typeof (Enum));
301 case TypeCode.Single:
302 return tot == TypeCode.Double || to == typeof (object);
304 /* TODO: handle valuetype -> byref */
305 if (to == typeof (object) && from.IsValueType)
308 return to.IsAssignableFrom (from);
312 private static bool check_arguments (Type[] types, ParameterInfo[] args) {
313 for (int i = 0; i < types.Length; ++i) {
314 if (!check_type (types [i], args [i].ParameterType))
320 public override MethodBase SelectMethod (BindingFlags bindingAttr, MethodBase[] match, Type[] types, ParameterModifier[] modifiers)
326 throw new ArgumentNullException ("match");
328 /* first look for an exact match... */
329 for (i = 0; i < match.Length; ++i) {
331 ParameterInfo[] args = m.GetParameters ();
332 if (args.Length != types.Length)
334 for (j = 0; j < types.Length; ++j) {
335 if (types [j] != args [j].ParameterType)
338 if (j == types.Length)
342 if ((int)(bindingAttr & BindingFlags.ExactBinding) != 0)
345 MethodBase result = null;
346 for (i = 0; i < match.Length; ++i) {
348 ParameterInfo[] args = m.GetParameters ();
349 if (args.Length != types.Length)
351 if (!check_arguments (types, args))
355 result = GetBetterMethod (result, m, types);
363 MethodBase GetBetterMethod (MethodBase m1, MethodBase m2, Type [] types)
366 if (m1.IsGenericMethodDefinition &&
367 !m2.IsGenericMethodDefinition)
369 if (m2.IsGenericMethodDefinition &&
370 !m1.IsGenericMethodDefinition)
374 ParameterInfo [] pl1 = m1.GetParameters ();
375 ParameterInfo [] pl2 = m2.GetParameters ();
377 for (int i = 0; i < pl1.Length; i++) {
378 int cmp = CompareCloserType (pl1 [i].ParameterType, pl2 [i].ParameterType);
379 if (cmp != 0 && prev != 0 && prev != cmp)
380 throw new AmbiguousMatchException ();
385 return prev > 0 ? m2 : m1;
387 bool va1 = (m1.CallingConvention & CallingConventions.VarArgs) != 0;
388 bool va2 = (m1.CallingConvention & CallingConventions.VarArgs) != 0;
394 throw new AmbiguousMatchException ();
397 int CompareCloserType (Type t1, Type t2)
402 if (t1.IsGenericParameter && !t2.IsGenericParameter)
404 if (!t1.IsGenericParameter && t2.IsGenericParameter)
407 if (t1.HasElementType && t2.HasElementType)
408 return CompareCloserType (
409 t1.GetElementType (),
410 t2.GetElementType ());
412 if (t1.IsSubclassOf (t2))
414 if (t2.IsSubclassOf (t1))
417 if (t1.IsInterface && Array.IndexOf (t2.GetInterfaces (), t1) >= 0)
419 if (t2.IsInterface && Array.IndexOf (t1.GetInterfaces (), t2) >= 0)
422 // What kind of cases could reach here?
426 public override PropertyInfo SelectProperty (BindingFlags bindingAttr, PropertyInfo[] match, Type returnType, Type[] indexes, ParameterModifier[] modifiers)
428 if (match == null || match.Length == 0)
429 throw new ArgumentException ("No properties provided", "match");
431 bool haveRet = (returnType != null);
432 int idxlen = (indexes != null) ? indexes.Length : -1;
433 PropertyInfo result = null;
435 int best_score = Int32.MaxValue - 1;
436 int fail_score = Int32.MaxValue;
439 for (i = match.Length - 1; i >= 0; i--) {
440 PropertyInfo p = match [i];
441 ParameterInfo[] args = p.GetIndexParameters ();
442 if (idxlen >= 0 && idxlen != args.Length)
445 if (haveRet && !check_type (p.PropertyType, returnType))
448 int score = Int32.MaxValue - 1;
450 score = check_arguments_with_score (indexes, args);
455 int new_level = GetDerivedLevel (p.DeclaringType);
456 if (result != null) {
457 if (best_score < score)
460 if (best_score == score) {
461 if (level == new_level) {
462 // Keep searching. May be there's something
468 if (level > new_level)
478 if (fail_score <= best_score)
479 throw new AmbiguousMatchException ();
484 static int check_arguments_with_score (Type [] types, ParameterInfo [] args)
488 for (int i = 0; i < types.Length; ++i) {
489 int res = check_type_with_score (types [i], args [i].ParameterType);
500 // 0 -> same type or null and !valuetype
502 // 2 -> value type that don't lose data
503 // 3 -> to == IsAssignableFrom
505 static int check_type_with_score (Type from, Type to)
508 return to.IsValueType ? -1 : 0;
513 if (to == typeof (object))
516 TypeCode fromt = Type.GetTypeCode (from);
517 TypeCode tot = Type.GetTypeCode (to);
522 case TypeCode.UInt16:
525 case TypeCode.UInt32:
527 case TypeCode.UInt64:
529 case TypeCode.Single:
530 case TypeCode.Double:
537 case TypeCode.UInt16:
539 case TypeCode.UInt32:
541 case TypeCode.UInt64:
543 case TypeCode.Single:
544 case TypeCode.Double:
547 return (from.IsEnum && to == typeof (Enum)) ? 1 : -1;
553 case TypeCode.Single:
554 case TypeCode.Double:
557 return (from.IsEnum && to == typeof (Enum)) ? 1 : -1;
558 case TypeCode.UInt16:
560 case TypeCode.UInt32:
562 case TypeCode.UInt64:
564 case TypeCode.Single:
565 case TypeCode.Double:
568 return (from.IsEnum && to == typeof (Enum)) ? 1 : -1;
573 case TypeCode.Single:
574 case TypeCode.Double:
577 return (from.IsEnum && to == typeof (Enum)) ? 1 : -1;
578 case TypeCode.UInt32:
580 case TypeCode.UInt64:
582 case TypeCode.Single:
583 case TypeCode.Double:
586 return (from.IsEnum && to == typeof (Enum)) ? 1 : -1;
590 case TypeCode.Single:
591 case TypeCode.Double:
594 return (from.IsEnum && to == typeof (Enum)) ? 1 : -1;
595 case TypeCode.UInt64:
598 case TypeCode.Single:
599 case TypeCode.Double:
602 return (from.IsEnum && to == typeof (Enum)) ? 1 : -1;
603 case TypeCode.Single:
604 return tot == TypeCode.Double ? 2 : -1;
606 return (to.IsAssignableFrom (from)) ? 3 : -1;