static IEnumerable <MethodInfo> ApplyBindingFlags(this IEnumerable <MethodInfo> infos, BindingFlags flags) { bool pub = flags.HasFlag(BindingFlags.Public); bool priv = flags.HasFlag(BindingFlags.NonPublic); if (priv && !pub) { infos = infos.Where(m => m.IsPrivate); } else if (pub && !priv) { infos = infos.Where(m => m.IsPublic); } bool stat = flags.HasFlag(BindingFlags.Static); bool inst = flags.HasFlag(BindingFlags.Instance); if (stat && !inst) { infos = infos.Where(m => m.IsStatic); } else if (inst && !stat) { infos = infos.Where(m => !m.IsStatic); } return(infos); }
private static IEnumerable <PropertyInfo> FilterOnPublicAndNonPublic(IEnumerable <PropertyInfo> query, BindingFlags bindingFlags) { var isPublic = bindingFlags.HasFlag(BindingFlags.Public); var isNonPublic = bindingFlags.HasFlag(BindingFlags.NonPublic); ValidatePublicAndNonPublicBindingFlags(isPublic, isNonPublic); if (isPublic && !isNonPublic) { query = query.Where(x => (x.CanRead && x.GetMethod.IsPublic) || (x.CanWrite && x.SetMethod.IsPublic)); } // ReSharper disable once ConditionIsAlwaysTrueOrFalse else if (!isPublic && isNonPublic) { // IsFamilyOrAssembly == protected internal // IsFamily == protected // IsAssembly == internal // IsPrivate == private query = query.Where(x => (x.CanRead && (x.GetMethod.IsFamilyOrAssembly || x.GetMethod.IsFamily || x.GetMethod.IsAssembly || x.GetMethod.IsPrivate)) || (x.CanWrite && (x.SetMethod.IsFamilyOrAssembly || x.SetMethod.IsFamily || x.SetMethod.IsAssembly || x.SetMethod.IsPrivate))); } return(query); }
private static bool Filter(TypeInfo Info, BindingFlags Flags) { bool Return = false; if (Flags.HasFlag(BindingFlags.DeclaredOnly)) { Return |= Info.IsNested; } if (Flags.HasFlag(BindingFlags.Instance)) { Return |= !(Info.IsAbstract | Info.IsSealed); } if (Flags.HasFlag(BindingFlags.Static)) { Return |= Info.IsAbstract | Info.IsSealed; } if (Flags.HasFlag(BindingFlags.Public)) { Return |= Info.IsPublic; } if (Flags.HasFlag(BindingFlags.NonPublic)) { Return |= Info.IsNotPublic; } return(Return); }
protected object InvokeStandardMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters) { BindingFlags processedInvokeAttr = invokeAttr; if ((processedInvokeAttr.HasFlag(BindingFlags.GetProperty) || processedInvokeAttr.HasFlag(BindingFlags.PutDispProperty)) && !_properties.Any(p => p.Name == name) && _fields.Any(p => p.Name == name)) { if (processedInvokeAttr.HasFlag(BindingFlags.GetProperty)) { processedInvokeAttr &= ~BindingFlags.GetProperty; processedInvokeAttr |= BindingFlags.GetField; } else if (processedInvokeAttr.HasFlag(BindingFlags.PutDispProperty)) { processedInvokeAttr &= ~BindingFlags.PutDispProperty; processedInvokeAttr |= BindingFlags.SetField; } } object result = _type.InvokeMember(name, processedInvokeAttr, binder, target, args, modifiers, culture, namedParameters); return(result); }
public override bool HasMember(EvaluationContext ctx, object tt, string memberName, BindingFlags bindingFlags) { CorEvaluationContext cctx = (CorEvaluationContext)ctx; CorType ct = (CorType)tt; while (ct != null) { Type type = ct.GetTypeInfo(cctx.Session); FieldInfo field = type.GetField(memberName, bindingFlags); if (field != null) { return(true); } PropertyInfo prop = type.GetProperty(memberName, bindingFlags); if (prop != null) { MethodInfo getter = prop.CanRead ? prop.GetGetMethod(bindingFlags.HasFlag(BindingFlags.NonPublic)) : null; if (getter != null) { return(true); } } if (bindingFlags.HasFlag(BindingFlags.DeclaredOnly)) { break; } ct = ct.Base; } return(false); }
public override bool TryInvokeAuxMember(IHostInvokeContext context, string name, BindingFlags invokeFlags, object[] args, object[] bindArgs, out object result) { var type = GetSpecificTypeNoThrow(); if (type != null) { var nestedTypes = type.GetScriptableNestedTypes(invokeFlags, context.DefaultAccess).Where(testType => testType.GetRootName() == name).ToIList(); if (nestedTypes.Count > 0) { var tempResult = Wrap(nestedTypes.Select(testType => testType.ApplyTypeArguments(type.GetGenericArguments())).ToArray()); if (invokeFlags.HasFlag(BindingFlags.InvokeMethod)) { if (tempResult.TryInvoke(context, invokeFlags, args, bindArgs, out result)) { return(true); } if (!invokeFlags.HasFlag(BindingFlags.GetField) && !invokeFlags.HasFlag(BindingFlags.GetProperty)) { return(false); } } result = tempResult; return(true); } } result = null; return(false); }
private static MethodInfo FindMethod(Type type, string name, BindingFlags flags) { MethodInfo[] methods = Methods.Where(a => a.DeclaringType == type && a.Name == name).ToArray(); foreach (MethodInfo method in methods) { if (flags.HasFlag(BindingFlags.NonPublic) && !method.IsPrivate) { continue; } if (flags.HasFlag(BindingFlags.Public) && !method.IsPublic) { continue; } if (flags.HasFlag(BindingFlags.Static) && !method.IsStatic) { continue; } if (flags.HasFlag(BindingFlags.Instance) && method.IsStatic) { continue; } return(method); } return(null); }
static IEnumerable <PropertyInfo> ApplyBindingFlags(this IEnumerable <PropertyInfo> infos, BindingFlags flags) { bool pub = flags.HasFlag(BindingFlags.Public); bool priv = flags.HasFlag(BindingFlags.NonPublic); if (pub && !priv) { infos = infos.Where(p => (p.GetMethod != null && p.GetMethod.IsPublic) || (p.SetMethod != null && p.SetMethod.IsPublic)); } if (priv && !pub) { infos = infos.Where(p => (p.GetMethod == null || p.GetMethod.IsPrivate) && (p.SetMethod == null || p.SetMethod.IsPrivate)); } bool stat = flags.HasFlag(BindingFlags.Static); bool inst = flags.HasFlag(BindingFlags.Instance); if (stat && !inst) { infos = infos.Where(p => (p.GetMethod != null && p.GetMethod.IsStatic) || (p.SetMethod != null && p.SetMethod.IsStatic)); } else if (inst && !stat) { infos = infos.Where(p => (p.GetMethod != null && !p.GetMethod.IsStatic) || (p.SetMethod != null && !p.SetMethod.IsStatic)); } return(infos); }
/// <inheritdoc /> public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr) { var candidates = new List <ConstructorInfo>(this.constructors.Length); foreach (var constructor in this.constructors) { // Checks the visibility bool matchVisibility = false; if (bindingAttr.HasFlag(BindingFlags.Public) && constructor.IsPublic) { matchVisibility = true; } else if (bindingAttr.HasFlag(BindingFlags.NonPublic) && !constructor.IsPublic) { matchVisibility = true; } if (!matchVisibility) { continue; } // Checks static/non static if (bindingAttr.HasFlag(BindingFlags.Static) && constructor.IsStatic) { candidates.Add(constructor); } else if (bindingAttr.HasFlag(BindingFlags.Instance) && !constructor.IsStatic) { candidates.Add(constructor); } } return(candidates.ToArray()); }
public override System.Reflection.MethodInfo[] GetMethods(BindingFlags bindingAttr) { bool showPrivate = bindingAttr.HasFlag(BindingFlags.NonPublic); bool showPublic = bindingAttr.HasFlag(BindingFlags.Public); return(_methods.Where(x => x.IsPublic && showPublic || x.IsPrivate && showPrivate).ToArray()); }
private static FieldInfo FindField(Type type, string name, BindingFlags flags) { FieldInfo[] fields = Fields.Where(a => a.DeclaringType == type && a.Name == name).ToArray(); foreach (FieldInfo field in fields) { if (flags.HasFlag(BindingFlags.NonPublic) && !field.IsPrivate) { continue; } if (flags.HasFlag(BindingFlags.Public) && !field.IsPublic) { continue; } if (flags.HasFlag(BindingFlags.Static) && !field.IsStatic) { continue; } if (flags.HasFlag(BindingFlags.Instance) && field.IsStatic) { continue; } return(field); } return(null); }
private static bool Filter(MethodInfo Info, BindingFlags Flags) { bool Return = false; if (Flags.HasFlag(BindingFlags.DeclaredOnly)) { Return |= Info.IsFamily; } if (Flags.HasFlag(BindingFlags.Instance)) { Return |= !Info.IsStatic; } if (Flags.HasFlag(BindingFlags.Static)) { Return |= Info.IsStatic; } if (Flags.HasFlag(BindingFlags.Public)) { Return |= Info.IsPublic; } if (Flags.HasFlag(BindingFlags.NonPublic)) { Return |= !Info.IsPublic; } return(Return); }
public static MethodInfo GetMethod(this Type type, string name, BindingFlags bindingFlags) { var isPublic = !bindingFlags.HasFlag(BindingFlags.NonPublic); var isStatic = bindingFlags.HasFlag(BindingFlags.Static); return(type.GetRuntimeMethods() .Where(m => m.IsPublic == isPublic && m.IsStatic == isStatic) .FirstOrDefault(m => m.Name == name)); }
private static bool TestAccessibility(MethodBase member, BindingFlags bindingFlags) { bool visibility = (member.IsPublic && bindingFlags.HasFlag(BindingFlags.Public)) || (!member.IsPublic && bindingFlags.HasFlag(BindingFlags.NonPublic)); bool instance = (member.IsStatic && bindingFlags.HasFlag(BindingFlags.Static)) || (!member.IsStatic && bindingFlags.HasFlag(BindingFlags.Instance)); return visibility && instance; }
public static MethodInfo [] GetMethods (this Type type, BindingFlags flags) { var methods = type.GetRuntimeMethods (); return methods.Where (m => ((flags.HasFlag (BindingFlags.Static) == m.IsStatic) || (flags.HasFlag (BindingFlags.Instance) == !m.IsStatic) ) && (flags.HasFlag (BindingFlags.Public) == m.IsPublic) ).ToArray (); }
private static bool check(MethodBase a, BindingFlags flags) { if (flags.HasFlag(BindingFlags.NonPublic) && a.IsPublic) return false; if (flags.HasFlag(BindingFlags.Public) && !a.IsPublic) return false; if (flags.HasFlag(BindingFlags.Static) && !a.IsStatic) return false; return true; }
public static ConstructorInfo [] GetConstructors (this Type type, BindingFlags flags) { var props = type.GetTypeInfo ().DeclaredConstructors; return props.Where (p => ((flags.HasFlag (BindingFlags.Static) == p.IsStatic) || (flags.HasFlag (BindingFlags.Instance) == !p.IsStatic) ) && (flags.HasFlag (BindingFlags.Public) == p.IsPublic) ).ToArray (); }
public static FieldInfo [] GetFields(this Type type, BindingFlags flags) { var fields = type.GetRuntimeFields(); return(fields.Where(p => ((flags.HasFlag(BindingFlags.Static) == p.IsStatic) || (flags.HasFlag(BindingFlags.Instance) == !p.IsStatic) ) && (flags.HasFlag(BindingFlags.Public) == p.IsPublic) ).ToArray()); }
private static bool TestAccessibility(MethodBase member, BindingFlags bindingFlags) { bool visibility = (member.IsPublic && bindingFlags.HasFlag(BindingFlags.Public)) || (!member.IsPublic && bindingFlags.HasFlag(BindingFlags.NonPublic)); bool instance = (member.IsStatic && bindingFlags.HasFlag(BindingFlags.Static)) || (!member.IsStatic && bindingFlags.HasFlag(BindingFlags.Instance)); return(visibility && instance); }
/// <summary> /// /// </summary> /// <param name="flags"></param> /// <returns></returns> private string CreateQuery(BindingFlags flags) { string query = string.Empty; query += $"?network={flags.HasFlag(BindingFlags.NETWORK).ToString().ToLower()}"; query += $"&device={flags.HasFlag(BindingFlags.DEVICE).ToString().ToLower()}"; query += $"&endpoint={flags.HasFlag(BindingFlags.ENDPOINT).ToString().ToLower()}"; query += $"&full={flags.HasFlag(BindingFlags.FULL).ToString().ToLower()}"; return(query); }
private bool MatchesBindingFlags(MemberInfo member) { if (_flags.HasFlag(BindingFlags.Static) && _flags.HasFlag(BindingFlags.Instance)) { return(true); } return (!((IsStatic(member) && !_flags.HasFlag(BindingFlags.Static)) || (!IsStatic(member) && !_flags.HasFlag(BindingFlags.Instance)))); }
private static bool AreBindingFlagsMatching(FieldInfo fieldInfo, BindingFlags bindingAttr) { var publicFlag = bindingAttr.HasFlag(BindingFlags.Public); var nonPublicFlag = bindingAttr.HasFlag(BindingFlags.NonPublic); var staticFlag = bindingAttr.HasFlag(BindingFlags.Static); var instanceFlag = bindingAttr.HasFlag(BindingFlags.Instance); return ((fieldInfo.IsPublic && publicFlag) || (!fieldInfo.IsPublic && nonPublicFlag)) && ((fieldInfo.IsStatic && staticFlag) || (!fieldInfo.IsStatic && instanceFlag)); }
public static PropertyInfo [] GetProperties(this Type type, BindingFlags flags) { var props = type.GetRuntimeProperties(); return(props.Where(p => ((flags.HasFlag(BindingFlags.Static) == (p.GetMethod != null && p.GetMethod.IsStatic)) || (flags.HasFlag(BindingFlags.Instance) == (p.GetMethod != null && !p.GetMethod.IsStatic)) ) && (flags.HasFlag(BindingFlags.Public) == (p.GetMethod != null && p.GetMethod.IsPublic) )).ToArray()); }
private static bool AreBindingFlagsMatching(FieldInfo fieldInfo, BindingFlags bindingAttr) { var publicFlag = bindingAttr.HasFlag(BindingFlags.Public); var nonPublicFlag = bindingAttr.HasFlag(BindingFlags.NonPublic); var staticFlag = bindingAttr.HasFlag(BindingFlags.Static); var instanceFlag = bindingAttr.HasFlag(BindingFlags.Instance); return(((fieldInfo.IsPublic && publicFlag) || (!fieldInfo.IsPublic && nonPublicFlag)) && ((fieldInfo.IsStatic && staticFlag) || (!fieldInfo.IsStatic && instanceFlag))); }
public override PropertyInfo[] GetProperties(BindingFlags bindingAttr) { bool showPrivate = bindingAttr.HasFlag(BindingFlags.NonPublic); bool showPublic = bindingAttr.HasFlag(BindingFlags.Public); return(_properties.Where(x => { var isPublic = (x.GetMethod?.IsPublic) == true || (x.SetMethod?.IsPublic) == true; return isPublic && showPublic || !isPublic && showPrivate; }).ToArray()); }
public static EventInfo [] GetEvents(this Type type, BindingFlags flags) { var props = type.GetRuntimeEvents(); return(props.Where(p => ((flags.HasFlag(BindingFlags.Static) == p.AddMethod.IsStatic) || (flags.HasFlag(BindingFlags.Instance) == !p.AddMethod.IsStatic) ) && (flags.HasFlag(BindingFlags.Public) == p.AddMethod.IsPublic) ).ToArray()); }
public static MemberInfo[] GetMembers(this Type t, BindingFlags flags) { #if NETFX_CORE if (!flags.HasFlag(BindingFlags.Instance) && !flags.HasFlag(BindingFlags.Static)) { return(null); } return(t.GetMembers()); #else throw new NotImplementedException(); #endif }
public static MemberInfo[] GetMembers(this Type t, BindingFlags flags) { #if NETFX_CORE if (!flags.HasFlag(BindingFlags.Instance) && !flags.HasFlag(BindingFlags.Static)) return null; var ti = t.GetTypeInfo(); var result = new List<MemberInfo>(); result.AddRange(ti.DeclaredMembers); return result.ToArray(); #else throw new NotImplementedException(); #endif }
public object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters) { var numberOfUnnamedArgs = (args == null) ? 0 : args.Length; var numberOfNamedArgs = (namedParameters == null) ? 0 : namedParameters.Length; var isSupportedInvocation = ((name == "CreateObject") && (target == this) && (numberOfUnnamedArgs == 1) && invokeAttr.HasFlag(BindingFlags.InvokeMethod) && (numberOfNamedArgs == 0)) || ((name == "Write") && (target == this) && (numberOfUnnamedArgs == 1) && invokeAttr.HasFlag(BindingFlags.InvokeMethod) && (numberOfNamedArgs == 0)) || ((name == "Redirect") && (target == this) && (numberOfUnnamedArgs == 1) && invokeAttr.HasFlag(BindingFlags.InvokeMethod) && (numberOfNamedArgs == 0)); if (isSupportedInvocation) return _target.GetType().InvokeMember(name, invokeAttr, binder, _target, args); throw new MissingMemberException($"Invalid InvokeMember call ({name})"); }
private static IEnumerable <Type> GetTypeChain(Type t, BindingFlags flags) { do { yield return(t); if (flags.HasFlag(BindingFlags.DeclaredOnly) || !flags.HasFlag(BindingFlags.FlattenHierarchy)) { break; } t = t.GetTypeInfo().BaseType; }while(t != null); }
/** * Tests the following BindingFlags: * Public, NonPublic, Static, Instance, DeclaredOnly. */ private static bool TestBindingFlags(Type t, MethodInfo method, BindingFlags flags) { #if NETFX_CORE var isValid = (flags.HasFlag(BindingFlags.Public) && method.IsPublic) || (flags.HasFlag(BindingFlags.NonPublic) && !method.IsPublic); isValid &= (flags.HasFlag(BindingFlags.Static) && method.IsStatic) || (flags.HasFlag(BindingFlags.Instance) && !method.IsStatic); if (flags.HasFlag(BindingFlags.DeclaredOnly)) { isValid &= method.DeclaringType == t; } return(isValid); #else throw new NotImplementedException(); #endif }
public static bool FindProperties(string name, Type owner, List <PropertyInfo> foundProperties, BindingFlags bindingFlags = BINDING_FLAGS, HashSet <Type> highestParents = null, bool searchParent = false) { var parentType = owner; while (parentType != null) { var properties = parentType.GetProperties(bindingFlags); foreach (var propertyInfo in properties) { if (bindingFlags.HasFlag(BindingFlags.SetProperty) && propertyInfo.SetMethod == null) { continue; } if (propertyInfo.GetMethod == null) { continue; } if (propertyInfo.Name == name) { foundProperties.AddUnique(propertyInfo); } } parentType = parentType.BaseType; if (highestParents.Contains(parentType)) { break; } } return(foundProperties.Count > 0); }
public static IEnumerable<PropertyInfo> GetProperties(this Type type, BindingFlags bindingFlags) { IList<PropertyInfo> properties = (bindingFlags.HasFlag(BindingFlags.DeclaredOnly)) ? type.GetTypeInfo().DeclaredProperties.ToList() : type.GetTypeInfo().GetPropertiesRecursive(); return properties.Where(p => TestAccessibility(p, bindingFlags)); }
private static bool check(MethodBase a, BindingFlags flags) { if (flags.HasFlag(BindingFlags.NonPublic) && a.IsPublic) { return(false); } if (flags.HasFlag(BindingFlags.Public) && !a.IsPublic) { return(false); } if (flags.HasFlag(BindingFlags.Static) && !a.IsStatic) { return(false); } return(true); }
public static MethodInfo GetMethod(this Type This, string name, BindingFlags flags = default(BindingFlags)) { var ti = This.GetTypeInfo(); var ret = ti.GetDeclaredMethod(name); if (ret != null || !flags.HasFlag(BindingFlags.FlattenHierarchy) || ti.BaseType == null) return ret; return ti.BaseType.GetMethod(name, flags); }
public static MethodInfo GetMethod(this Type This, string methodName, Type[] paramTypes, BindingFlags flags = default(BindingFlags)) { var ti = This.GetTypeInfo(); var ret = ti.GetDeclaredMethods(methodName) .FirstOrDefault(x => { return paramTypes.Zip(x.GetParameters().Select(y => y.ParameterType), (l, r) => l == r).All(y => y != false); }); if (ret != null || !flags.HasFlag(BindingFlags.FlattenHierarchy) || ti.BaseType == null) return ret; return ti.BaseType.GetMethod(methodName, paramTypes, flags); }
protected virtual object InvokeInternal(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, System.Globalization.CultureInfo culture) { if (invokeAttr.HasFlag(BindingFlags.GetProperty)) { var prop = GetProperty(name, invokeAttr); if (prop == null) { throw new MissingFieldException("ScriptDrivenObject", name); } return prop.GetValue(target, null); } else if (invokeAttr.HasFlag(BindingFlags.SetProperty)) { var prop = GetProperty(name, invokeAttr); if (prop == null) { throw new MissingFieldException("ScriptDrivenObject", name); } prop.SetValue(target, args[0], invokeAttr, binder, null, culture); return null; } else if (invokeAttr.HasFlag(BindingFlags.InvokeMethod)) { var method = GetMethod(name, invokeAttr); if (method == null) { throw new MissingMethodException("ScriptDrivenObject", name); } return method.Invoke(target, invokeAttr, binder, args, culture); } else { throw new ArgumentException("No flags for property access or method call"); } }
protected override object InnerInvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters) { object[] processedArgs = TypeMappingHelpers.MapToHostType(args); object result; if (name == SpecialMemberName.Default && invokeAttr.HasFlag(BindingFlags.CreateInstance)) { if (_engineMode != JsEngineMode.Classic && processedArgs.Length > 0) { processedArgs = processedArgs.Skip(1).ToArray(); } result = Activator.CreateInstance(_type, processedArgs); } else { result = InvokeStandardMember(name, invokeAttr, binder, target, processedArgs, modifiers, culture, namedParameters); } return TypeMappingHelpers.MapToScriptType(result, _engineMode); }
public static FieldInfo[] GetFields(this Type t, BindingFlags flags) { #if NETFX_CORE if (!flags.HasFlag(BindingFlags.Instance) && !flags.HasFlag(BindingFlags.Static)) return null; var ti = t.GetTypeInfo(); var origFields = ti.DeclaredFields; var results = new List<FieldInfo>(); foreach (var field in origFields) { var isValid = (flags.HasFlag(BindingFlags.Public) && field.IsPublic) || (flags.HasFlag(BindingFlags.NonPublic) && !field.IsPublic); isValid &= (flags.HasFlag(BindingFlags.Static) && field.IsStatic) || (flags.HasFlag(BindingFlags.Instance) && !field.IsStatic); if (flags.HasFlag(BindingFlags.DeclaredOnly)) isValid &= field.DeclaringType == t; results.Add(field); } return results.ToArray(); #else throw new NotImplementedException(); #endif }
/** * Tests the following BindingFlags: * Public, NonPublic, Static, Instance, DeclaredOnly. */ private static bool TestBindingFlags(Type t, MethodInfo method, BindingFlags flags) { #if NETFX_CORE var isValid = (flags.HasFlag(BindingFlags.Public) && method.IsPublic) || (flags.HasFlag(BindingFlags.NonPublic) && !method.IsPublic); isValid &= (flags.HasFlag(BindingFlags.Static) && method.IsStatic) || (flags.HasFlag(BindingFlags.Instance) && !method.IsStatic); if (flags.HasFlag(BindingFlags.DeclaredOnly)) isValid &= method.DeclaringType == t; return isValid; #else throw new NotImplementedException(); #endif }
public override bool TryInvoke(BindingFlags invokeFlags, object[] args, object[] bindArgs, out object result) { if (!invokeFlags.HasFlag(BindingFlags.InvokeMethod) || (args.Length < 1)) { result = null; return false; } if (!args.All(arg => arg is HostType)) { throw new ArgumentException("Invalid generic type argument"); } var templates = types.Where(type => !type.IsSpecific()).ToArray(); var typeArgs = args.Cast<HostType>().Select(hostType => hostType.GetTypeArg()).ToArray(); var template = templates.FirstOrDefault(testTemplate => testTemplate.GetGenericParamCount() == typeArgs.Length); if (template == null) { throw new TypeLoadException(MiscHelpers.FormatInvariant("Could not find a matching generic type definition for '{0}'", templates[0].GetRootName())); } result = Wrap(template.MakeSpecificType(typeArgs)); return true; }
public MethodMirror[] GetMethodsByNameFlags (string name, BindingFlags flags, bool ignoreCase) { if (vm.conn.Version.AtLeast (2, 6)) { long[] ids = vm.conn.Type_GetMethodsByNameFlags (id, name, (int)flags, ignoreCase); MethodMirror[] m = new MethodMirror [ids.Length]; for (int i = 0; i < ids.Length; ++i) m [i] = vm.GetMethod (ids [i]); return m; } else { if (flags.HasFlag (BindingFlags.IgnoreCase)) { flags &= ~BindingFlags.IgnoreCase; ignoreCase = true; } if (flags == BindingFlags.Default) flags = BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Instance|BindingFlags.Static; MethodAttributes access = (MethodAttributes) 0; bool matchInstance = false; bool matchStatic = false; if (flags.HasFlag (BindingFlags.NonPublic)) { access |= MethodAttributes.Private; flags &= ~BindingFlags.NonPublic; } if (flags.HasFlag (BindingFlags.Public)) { access |= MethodAttributes.Public; flags &= ~BindingFlags.Public; } if (flags.HasFlag (BindingFlags.Instance)) { flags &= ~BindingFlags.Instance; matchInstance = true; } if (flags.HasFlag (BindingFlags.Static)) { flags &= ~BindingFlags.Static; matchStatic = true; } if ((int) flags != 0) throw new NotImplementedException (); var res = new List<MethodMirror> (); foreach (MethodMirror m in GetMethods ()) { if ((m.Attributes & access) == (MethodAttributes) 0) continue; if (!((matchStatic && m.IsStatic) || (matchInstance && !m.IsStatic))) continue; if ((!ignoreCase && m.Name == name) || (ignoreCase && m.Name.Equals (name, StringComparison.CurrentCultureIgnoreCase))) res.Add (m); } return res.ToArray (); } }
private IEnumerable<IMethod> IterateMethods(BindingFlags bindingFlags) { foreach (var method in this.typeDef.GetMembers() .Where(m => m is MethodSymbol && !this.IsAny(((MethodSymbol)m).MethodKind, MethodKind.Constructor, MethodKind.StaticConstructor)) .Select(f => new MetadataMethodAdapter(f as MethodSymbol, this.GenericContext))) { yield return method; } if (bindingFlags.HasFlag(BindingFlags.FlattenHierarchy)) { var baseType = this.BaseType; if (baseType != null) { foreach (var method in baseType.GetMethods(bindingFlags)) { yield return method; } } } }
public static ConstructorInfo[] GetConstructors(this Type type, BindingFlags flags) { var props = type.GetTypeInfo ().DeclaredConstructors; return props.Where (p => ((flags.HasFlag (BindingFlags.Static) == p.IsStatic) || (flags.HasFlag (BindingFlags.Instance) == !p.IsStatic) ) && (flags.HasFlag (BindingFlags.Public) == p.IsPublic) ).ToArray (); }
public static MethodInfo[] GetMethods(this Type type, BindingFlags flags) { var methods = type.GetRuntimeMethods (); return methods.Where (m => ((flags.HasFlag (BindingFlags.Static) == m.IsStatic) || (flags.HasFlag (BindingFlags.Instance) == !m.IsStatic) ) && (flags.HasFlag (BindingFlags.Public) == m.IsPublic) ).ToArray (); }
public override bool TryInvokeAuxMember(string memberName, BindingFlags invokeFlags, object[] args, object[] bindArgs, out object result) { if (invokeFlags.HasFlag(BindingFlags.InvokeMethod)) { if (memberName == "get") { result = target.InvokeMember(name, BindingFlags.GetProperty, args, bindArgs, null); return true; } if (memberName == "set") { result = target.InvokeMember(name, BindingFlags.SetProperty, args, bindArgs, null); return true; } } result = null; return false; }
public static EventInfo[] GetEvents(this Type type, BindingFlags flags) { var props = type.GetRuntimeEvents (); return props.Where (p => ((flags.HasFlag (BindingFlags.Static) == p.AddMethod.IsStatic) || (flags.HasFlag (BindingFlags.Instance) == !p.AddMethod.IsStatic) ) && (flags.HasFlag (BindingFlags.Public) == p.AddMethod.IsPublic) ).ToArray (); }
public object InvokeMember(string name, BindingFlags invokeFlags, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters) { if (invokeFlags.HasFlag(BindingFlags.InvokeMethod)) { if (name == SpecialMemberNames.Default) { return Invoke(args, false); } return InvokeMethod(name, args); } if (invokeFlags.HasFlag(BindingFlags.GetField)) { int index; if (int.TryParse(name, NumberStyles.Integer, CultureInfo.InvariantCulture, out index)) { return GetProperty(index); } return GetProperty(name); } if (invokeFlags.HasFlag(BindingFlags.SetField)) { if (args.Length != 1) { throw new InvalidOperationException("Invalid argument count"); } var value = args[0]; int index; if (int.TryParse(name, NumberStyles.Integer, CultureInfo.InvariantCulture, out index)) { SetProperty(index, value); return value; } SetProperty(name, value); return value; } throw new InvalidOperationException("Invalid member access mode"); }
public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr) { // Do not expose non-public constructors for composition, since // this is the behavior of all other frameworks (including Microsoft.Composition!) if (bindingAttr.HasFlag(BindingFlags.NonPublic)) bindingAttr &= ~BindingFlags.NonPublic; var ctor = base.GetConstructors(bindingAttr).OrderByDescending(c => c.GetParameters().Length).FirstOrDefault(); if (ctor != null) return new ConstructorInfo[] { new ImportingConstructorInfo(ctor) }; return new ConstructorInfo[0]; }
public static FieldInfo[] GetFields(this Type type, BindingFlags flags) { var fields = type.GetRuntimeFields (); return fields.Where (p => ((flags.HasFlag (BindingFlags.Static) == p.IsStatic) || (flags.HasFlag (BindingFlags.Instance) == !p.IsStatic) ) && (flags.HasFlag (BindingFlags.Public) == p.IsPublic) ).ToArray (); }
private static bool IsConformWithBindingFlags(FieldInfo method, BindingFlags bindingFlags) { if (method.IsPublic && !bindingFlags.HasFlag(BindingFlags.Public)) return false; if (method.IsPrivate && !bindingFlags.HasFlag(BindingFlags.NonPublic)) return false; if (method.IsStatic && !bindingFlags.HasFlag(BindingFlags.Static)) return false; if (!method.IsStatic && !bindingFlags.HasFlag(BindingFlags.Instance)) return false; return true; }
public override bool TryInvoke(BindingFlags invokeFlags, object[] args, object[] bindArgs, out object result) { result = target.InvokeMember(name, invokeFlags.HasFlag(BindingFlags.SetField) ? BindingFlags.SetProperty : BindingFlags.GetProperty, args, bindArgs, null); return true; }
public static IEnumerable<FieldInfo> GetFields(this Type type, BindingFlags bindingFlags) { IList<FieldInfo> fields = (bindingFlags.HasFlag(BindingFlags.DeclaredOnly)) ? type.GetTypeInfo().DeclaredFields.ToList() : type.GetTypeInfo().GetFieldsRecursive(); return fields.Where(f => TestAccessibility(f, bindingFlags)).ToList(); }
/** * This implementation currently ignores BindingFlags.FlattenHierarchy. */ public static MethodInfo[] GetMethods(this Type t, BindingFlags flags = BindingFlags.Public | BindingFlags.Instance) { #if NETFX_CORE if (!flags.HasFlag(BindingFlags.Instance) && !flags.HasFlag(BindingFlags.Static)) return null; var allMethods = t.GetMethods(); var resultList = new List<MethodInfo>(); foreach (var method in allMethods) { if (TestBindingFlags(t, method, flags)) resultList.Add(method); } return resultList.ToArray(); #else throw new NotImplementedException(); #endif }
/** * Attention: This implementation does not throw AmbiguousMatchException when more than one * property is found with the specified name and matching the specified binding constraints. * * This implementation currently ignores BindingFlags.FlattenHierarchy. */ public static PropertyInfo GetProperty(this Type type, string name, BindingFlags bindingAttr) { #if NETFX_CORE var props = type.GetProperties(bindingAttr); if (!props.Any()) return null; return props.FirstOrDefault(f => bindingAttr.HasFlag(BindingFlags.IgnoreCase) ? f.Name.ToLower() == name.ToLower() : f.Name == name); #else throw new NotImplementedException(); #endif }
public static MethodInfo[] GetMethods(this Type t, BindingFlags flags) { #if NETFX_CORE if (!flags.HasFlag(BindingFlags.Instance) && !flags.HasFlag(BindingFlags.Static)) return null; var ti = t.GetTypeInfo(); var allMethods = ti.DeclaredMethods; var resultList = new List<MethodInfo>(); foreach (var method in allMethods) { var isValid = (flags.HasFlag(BindingFlags.Public) && method.IsPublic) || (flags.HasFlag(BindingFlags.NonPublic) && !method.IsPublic); isValid &= (flags.HasFlag(BindingFlags.Static) && method.IsStatic) || (flags.HasFlag(BindingFlags.Instance) && !method.IsStatic); if (flags.HasFlag(BindingFlags.DeclaredOnly)) isValid &= method.DeclaringType == t; if (isValid) resultList.Add(method); } return resultList.ToArray(); #else throw new NotImplementedException(); #endif }
public static bool TryInvokeObject(object target, BindingFlags invokeFlags, object[] args, object[] bindArgs, bool tryDynamic, out object result) { var hostTarget = target as HostTarget; if (hostTarget != null) { if (hostTarget.TryInvoke(invokeFlags, args, bindArgs, out result)) { return true; } if (hostTarget is HostType) { return false; } target = hostTarget.InvokeTarget; tryDynamic = tryDynamic && typeof(IDynamicMetaObjectProvider).IsAssignableFrom(hostTarget.Type); } if ((target != null) && invokeFlags.HasFlag(BindingFlags.InvokeMethod)) { if (target is ScriptItem) { target = DelegateFactory.CreateFunc<object>(null, target, args.Length); } var del = target as Delegate; if (del != null) { result = InvokeDelegate(del, args); return true; } if (tryDynamic) { var dynamicMetaObjectProvider = target as IDynamicMetaObjectProvider; if (dynamicMetaObjectProvider != null) { if (dynamicMetaObjectProvider.GetMetaObject(Expression.Constant(target)).TryInvoke(args, out result)) { return true; } } } } result = null; return false; }
public static PropertyInfo[] GetProperties(this Type type, BindingFlags flags) { var props = type.GetRuntimeProperties (); return props.Where (p => ((flags.HasFlag (BindingFlags.Static) == (p.GetMethod != null && p.GetMethod.IsStatic)) || (flags.HasFlag (BindingFlags.Instance) == (p.GetMethod != null && !p.GetMethod.IsStatic)) ) && (flags.HasFlag (BindingFlags.Public) == (p.GetMethod != null && p.GetMethod.IsPublic) )).ToArray (); }
public static MemberInfo[] GetMembers(this Type t, BindingFlags flags) { #if NETFX_CORE if (!flags.HasFlag(BindingFlags.Instance) && !flags.HasFlag(BindingFlags.Static)) return null; return t.GetMembers(); #else throw new NotImplementedException(); #endif }
public override bool TryInvokeAuxMember(string name, BindingFlags invokeFlags, object[] args, object[] bindArgs, out object result) { var type = GetSpecificTypeNoThrow(); if (type != null) { var nestedTypes = type.GetNestedTypes(invokeFlags).Where(testType => testType.GetRootName() == name).ToIList(); if (nestedTypes.Count > 0) { var tempResult = Wrap(nestedTypes.Select(testType => testType.ApplyTypeArguments(type.GetGenericArguments())).ToArray()); if (invokeFlags.HasFlag(BindingFlags.InvokeMethod)) { return tempResult.TryInvoke(invokeFlags, args, bindArgs, out result); } result = tempResult; return true; } } result = null; return false; }