// moniker = Name.Space.Type::MethodName public static MethodInfo FindMethod(string methodMoniker, ClrMemberFlags methodFlags, params Type[] argumentTypes) { if (string.IsNullOrWhiteSpace(methodMoniker)) { throw new ArgumentNullException(nameof(methodMoniker)); } methodMoniker = methodMoniker.Split('(', StringSplitOptions.RemoveEmptyEntries).FirstOrDefault(); if (string.IsNullOrWhiteSpace(methodMoniker)) { throw new ArgumentException("Method moniker must be in the short format such as Namespace.TypeName::MethodName"); } StringBuilder buffer = new StringBuilder(); buffer.Append(methodMoniker); buffer.Append("("); if (null != argumentTypes) { buffer.AppendJoin(",", argumentTypes.Select(x => x.GetNormalizedName())); } buffer.Append(")"); return(ReflectionHelpers.FindMethod(methodMoniker, methodFlags)); }
public static MethodInfo FindMethod(this Type ownerType, string methodName, ClrMemberFlags methodFlags, params Type[] argumentTypes) { if (null == ownerType) { throw new ArgumentNullException(nameof(ownerType)); } if (string.IsNullOrWhiteSpace(methodName)) { throw new ArgumentNullException(nameof(methodName)); } BindingFlags bindingFlags = BindingFlags.Default; if (methodFlags.HasFlag(ClrMemberFlags.Instance)) { bindingFlags |= BindingFlags.Instance; } if (methodFlags.HasFlag(ClrMemberFlags.Static)) { bindingFlags |= BindingFlags.Static; } if (methodFlags.HasFlag(ClrMemberFlags.Public)) { bindingFlags |= BindingFlags.Public; } if (methodFlags.HasFlag(ClrMemberFlags.NonPublic)) { bindingFlags |= BindingFlags.NonPublic; } return(ownerType.GetMethods(bindingFlags) .Where(x => 0 == string.Compare(x.Name, methodName, StringComparison.OrdinalIgnoreCase)) .Where(x => { var methodParameters = x.GetParameters(); if (null == argumentTypes || 0 == argumentTypes.Length) { return 0 == methodParameters.Length; } else { if (argumentTypes.Length != methodParameters.Length) { return false; } for (int loop = 0; loop < methodParameters.Length; loop++) { if (!methodParameters[loop].ParameterType.IsAssignableFrom(argumentTypes[loop])) { return false; } } } return true; }) .FirstOrDefault()); }
public static IEnumerable <MethodInfo> FindMethods(this Type type, ClrMemberFlags methodFlags = ClrMemberFlags.None) { if (null == type) { throw new ArgumentNullException(nameof(type)); } return(from m in type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance) where ( ClrMemberFlags.None == methodFlags || ( methodFlags.HasFlag(ClrMemberFlags.Instance) ? !m.IsStatic : true && methodFlags.HasFlag(ClrMemberFlags.Static) ? m.IsStatic : true && methodFlags.HasFlag(ClrMemberFlags.Public) ? m.IsPublic : true && methodFlags.HasFlag(ClrMemberFlags.NonPublic) ? !m.IsPublic : true && methodFlags.HasFlag(ClrMemberFlags.SpecialName) ? m.IsSpecialName : true ) ) select m); }
public static IEnumerable <Type> FindTypes <TBase>(string classNameSuffix = null, ClrMemberFlags typeFlags = ClrMemberFlags.Class) { Type typeOfTBase = typeof(TBase); return(ReflectionHelpers.FindTypes(t => { return ClrMemberFlags.None == typeFlags || (typeFlags.HasFlag(ClrMemberFlags.Class) ? t.IsClass : true && typeFlags.HasFlag(ClrMemberFlags.Concrete) ? !t.IsAbstract : true && typeFlags.HasFlag(ClrMemberFlags.NonPublic) ? t.IsNotPublic : true && typeFlags.HasFlag(ClrMemberFlags.Primitive) ? t.IsPrimitive : true && typeFlags.HasFlag(ClrMemberFlags.Public) ? t.IsPublic : true && typeFlags.HasFlag(ClrMemberFlags.SpecialName) ? t.IsSpecialName : true && typeFlags.HasFlag(ClrMemberFlags.NotSpecialName) ? !t.IsSpecialName : true) && typeOfTBase.IsAssignableFrom(t) && ( string.IsNullOrWhiteSpace(classNameSuffix) || t.Name.EndsWith(classNameSuffix, StringComparison.OrdinalIgnoreCase) ); })); }
// moniker = Name.Space.Type::MethodName(@param1Type ...) public static MethodInfo FindMethod(string methodMoniker, ClrMemberFlags methodFlags) { if (string.IsNullOrWhiteSpace(methodMoniker)) { throw new ArgumentNullException(nameof(methodMoniker)); } var matches = Regex.Matches(methodMoniker, @"^(?<classTypeName>\w+.*)::(?<methodName>\w+.*)\((?<parameters>.*)\)$", RegexOptions.Compiled | RegexOptions.IgnoreCase); string classTypeName = null, methodName = null; List <string> paramterTypes = new List <string>(); if (null != matches && 0 < matches.Count) { foreach (Match match in matches) { if (match.Success) { if (null == classTypeName) { var group = match.Groups["classTypeName"]; if (null != group && group.Success) { classTypeName = group.Value.Trim(); } } if (null == methodName) { var group = match.Groups["methodName"]; if (null != group && group.Success) { methodName = group.Value.Trim(); } } { var group = match.Groups["parameters"]; if (null != group && group.Success) { paramterTypes.AddRange(group.Value.Split(',', StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim())); } } } } } Type classType = Type.GetType(classTypeName, false, true); StringBuilder buffer = new StringBuilder(); buffer.Append(methodName); buffer.Append("("); buffer.AppendJoin(",", paramterTypes); buffer.Append(")"); if (null == classType) { throw new TypeLoadException($"Could not find or load the specified type '{classTypeName}'."); } try { return(classType.FindMethods(methodFlags).Where(m => paramterTypes.Count == m.GetParameters().Count() && 0 == string.Compare(m.GetNormalizedName(), buffer.ToString(), StringComparison.OrdinalIgnoreCase) ).Single()); } catch (InvalidOperationException innerException) { throw new InvalidOperationException($"Could not find method '{methodName}' matching the given signature. Have you forgotten to fully qualify all type names in the Namespace.TypeName format?", innerException); } }