static OverloadGenInfo ToOverloadGenInfo(MethodBase methodBase) { OverloadGenInfo result = null; if (methodBase is MethodInfo) { var methodInfo = methodBase as MethodInfo; result = new OverloadGenInfo() { ParameterInfos = methodInfo.GetParameters().Select(info => ToParameterGenInfo(info)).ToArray(), TypeName = methodInfo.ReturnType.GetFriendlyName(), IsVoid = methodInfo.ReturnType == typeof(void) }; FillEnumInfo(result, methodInfo.ReturnType); } else if (methodBase is ConstructorInfo) { var constructorInfo = methodBase as ConstructorInfo; result = new OverloadGenInfo() { ParameterInfos = constructorInfo.GetParameters().Select(info => ToParameterGenInfo(info)).ToArray(), TypeName = constructorInfo.DeclaringType.GetFriendlyName(), IsVoid = false }; } else { throw new NotSupportedException(); } result.HasParams = result.ParameterInfos.Any(info => info.IsParams); return(result); }
static List <OverloadGenInfo> ToOverloadGenInfo(MethodBase methodBase) { List <OverloadGenInfo> ret = new List <OverloadGenInfo>(); OverloadGenInfo result = null; if (methodBase is MethodInfo) { var methodInfo = methodBase as MethodInfo; result = new OverloadGenInfo() { ParameterInfos = methodInfo.GetParameters().Select(info => ToParameterGenInfo(info)).ToArray(), TypeName = methodInfo.ReturnType.GetFriendlyName(), IsVoid = methodInfo.ReturnType == typeof(void) }; FillEnumInfo(result, methodInfo.ReturnType); result.HasParams = result.ParameterInfos.Any(info => info.IsParams); ret.Add(result); var ps = methodInfo.GetParameters(); for (int i = ps.Length - 1; i >= 0; i--) { var value = HasValue(ps[i]); if (value != null) { result = new OverloadGenInfo() { ParameterInfos = methodInfo.GetParameters().Select(info => ToParameterGenInfo(info)).Take(i).ToArray(), TypeName = methodInfo.ReturnType.GetFriendlyName(), IsVoid = methodInfo.ReturnType == typeof(void) }; FillEnumInfo(result, methodInfo.ReturnType); result.HasParams = result.ParameterInfos.Any(info => info.IsParams); ret.Add(result); } else { break; } } } else if (methodBase is ConstructorInfo) { var constructorInfo = methodBase as ConstructorInfo; result = new OverloadGenInfo() { ParameterInfos = constructorInfo.GetParameters().Select(info => ToParameterGenInfo(info)).ToArray(), TypeName = constructorInfo.DeclaringType.GetFriendlyName(), IsVoid = false }; result.HasParams = result.ParameterInfos.Any(info => info.IsParams); ret.Add(result); var ps = constructorInfo.GetParameters(); for (int i = ps.Length - 1; i >= 0; i--) { var value = HasValue(ps[i]); if (value != null) { result = new OverloadGenInfo() { ParameterInfos = constructorInfo.GetParameters().Select(info => ToParameterGenInfo(info)).Take(i).ToArray(), TypeName = constructorInfo.DeclaringType.GetFriendlyName(), IsVoid = false }; result.HasParams = result.ParameterInfos.Any(info => info.IsParams); ret.Add(result); } else { break; } } } else { throw new NotSupportedException(); } return(ret); }
public static MethodGenInfo FromType(Type type, bool isCtor, List <MethodBase> overloads, List <MethodBase> extensionOverloads = null) { var ret = new List <OverloadGenInfo>(); if (overloads != null) { foreach (var iBase in overloads) { ret.AddRange(OverloadGenInfo.FromMethodBase(iBase)); } } if (extensionOverloads != null) { foreach (var iBase in extensionOverloads) { ret.AddRange(OverloadGenInfo.FromMethodBase(iBase, true)); } } string name; bool isStatic; if (isCtor) { if (type.IsValueType)//值类型添加无参构造 { if (!ret.Exists(m => m.ParameterInfos.Length == 0)) { ret.Add(new OverloadGenInfo() { ParameterInfos = new ParameterGenInfo[] { }, TypeName = type.GetFriendlyName(), IsVoid = false }); } } // 如果是构造函数此处固定赋值,因为像结构体的情况overloads不一定有含有元素 name = ".ctor"; isStatic = false; } else if (overloads != null) { name = overloads[0].Name; isStatic = overloads[0].IsStatic; } else { name = extensionOverloads[0].Name; isStatic = false; } var result = new MethodGenInfo() { Name = name, IsStatic = isStatic, HasOverloads = ret.Count > 1, OverloadCount = ret.Count, OverloadGroups = ret .GroupBy(m => m.ParameterInfos.Length + (m.HasParams ? 0 : 9999)) .Select(lst => { // some overloads are from the base class, some overloads may have the same parameters, so we need to distinct the overloads with same parameterinfo Dictionary <string, OverloadGenInfo> distincter = new Dictionary <string, OverloadGenInfo>(); foreach (var overload in lst) { string mark = overload.GetParameterInfosMark(); OverloadGenInfo existedOverload = null; if (!distincter.TryGetValue(mark, out existedOverload)) { distincter.Add(mark, overload); } else { // if the value in distincter is null. Means that this overload is unavailable(will cause ambigious) if (existedOverload == null) { continue; } if (!overload.EllipsisedParameters) { if (existedOverload == null || existedOverload.EllipsisedParameters) { distincter[mark] = overload; } } else { if (existedOverload.EllipsisedParameters) { distincter[mark] = null; } } } } return(distincter.Values.ToList().Where(item => item != null).ToArray()); }) .Where(lst => lst.Count() > 0) .ToArray() }; return(result); }
static List <OverloadGenInfo> ToOverloadGenInfo(MethodBase methodBase) { List <OverloadGenInfo> ret = new List <OverloadGenInfo>(); if (methodBase is MethodInfo) { var methodInfo = methodBase as MethodInfo; OverloadGenInfo mainInfo = new OverloadGenInfo() { ParameterInfos = methodInfo.GetParameters().Select(info => ToParameterGenInfo(info)).ToArray(), TypeName = RemoveRefAndToConstraintType(methodInfo.ReturnType).GetFriendlyName(), IsVoid = methodInfo.ReturnType == typeof(void) }; FillEnumInfo(mainInfo, methodInfo.ReturnType); mainInfo.HasParams = mainInfo.ParameterInfos.Any(info => info.IsParams); ret.Add(mainInfo); var ps = methodInfo.GetParameters(); for (int i = ps.Length - 1; i >= 0; i--) { OverloadGenInfo optionalInfo = null; if (ps[i].IsOptional) { optionalInfo = new OverloadGenInfo() { ParameterInfos = methodInfo.GetParameters().Select(info => ToParameterGenInfo(info)).Take(i).ToArray(), TypeName = RemoveRefAndToConstraintType(methodInfo.ReturnType).GetFriendlyName(), IsVoid = methodInfo.ReturnType == typeof(void) }; FillEnumInfo(optionalInfo, methodInfo.ReturnType); optionalInfo.HasParams = optionalInfo.ParameterInfos.Any(info => info.IsParams); ret.Add(optionalInfo); } else { break; } } } else if (methodBase is ConstructorInfo) { var constructorInfo = methodBase as ConstructorInfo; OverloadGenInfo mainInfo = new OverloadGenInfo() { ParameterInfos = constructorInfo.GetParameters().Select(info => ToParameterGenInfo(info)).ToArray(), TypeName = constructorInfo.DeclaringType.GetFriendlyName(), IsVoid = false }; mainInfo.HasParams = mainInfo.ParameterInfos.Any(info => info.IsParams); ret.Add(mainInfo); var ps = constructorInfo.GetParameters(); for (int i = ps.Length - 1; i >= 0; i--) { OverloadGenInfo optionalInfo = null; if (ps[i].IsOptional) { optionalInfo = new OverloadGenInfo() { ParameterInfos = constructorInfo.GetParameters().Select(info => ToParameterGenInfo(info)).Take(i).ToArray(), TypeName = constructorInfo.DeclaringType.GetFriendlyName(), IsVoid = false }; optionalInfo.HasParams = optionalInfo.ParameterInfos.Any(info => info.IsParams); ret.Add(optionalInfo); } else { break; } } } else { throw new NotSupportedException(); } return(ret); }
public static List <OverloadGenInfo> FromMethodBase(MethodBase methodBase, bool extensionMethod = false) { List <OverloadGenInfo> ret = new List <OverloadGenInfo>(); if (methodBase is MethodInfo) { var methodInfo = methodBase as MethodInfo; var parameters = methodInfo.GetParameters().Skip(extensionMethod ? 1 : 0).ToArray(); OverloadGenInfo mainInfo = new OverloadGenInfo() { ParameterInfos = parameters.Select(info => ParameterGenInfo.FromParameterInfo(info)).ToArray(), TypeName = Utils.RemoveRefAndToConstraintType(methodInfo.ReturnType).GetFriendlyName(), IsVoid = methodInfo.ReturnType == typeof(void), EllipsisedParameters = false, }; Utils.FillEnumInfo(mainInfo, methodInfo.ReturnType); mainInfo.HasParams = mainInfo.ParameterInfos.Any(info => info.IsParams); ret.Add(mainInfo); var ps = parameters; for (int i = ps.Length - 1; i >= 0; i--) { OverloadGenInfo optionalInfo = null; if (ps[i].IsOptional || mainInfo.ParameterInfos[i].IsParams) { optionalInfo = new OverloadGenInfo() { ParameterInfos = parameters.Select(info => ParameterGenInfo.FromParameterInfo(info)).Take(i).ToArray(), TypeName = Utils.RemoveRefAndToConstraintType(methodInfo.ReturnType).GetFriendlyName(), IsVoid = methodInfo.ReturnType == typeof(void), EllipsisedParameters = true, }; Utils.FillEnumInfo(optionalInfo, methodInfo.ReturnType); optionalInfo.HasParams = optionalInfo.ParameterInfos.Any(info => info.IsParams); ret.Add(optionalInfo); } else { break; } } } else if (methodBase is ConstructorInfo) { var constructorInfo = methodBase as ConstructorInfo; OverloadGenInfo mainInfo = new OverloadGenInfo() { ParameterInfos = constructorInfo.GetParameters().Select(info => ParameterGenInfo.FromParameterInfo(info)).ToArray(), TypeName = constructorInfo.DeclaringType.GetFriendlyName(), IsVoid = false, EllipsisedParameters = false, }; mainInfo.HasParams = mainInfo.ParameterInfos.Any(info => info.IsParams); ret.Add(mainInfo); var ps = constructorInfo.GetParameters(); for (int i = ps.Length - 1; i >= 0; i--) { OverloadGenInfo optionalInfo = null; if (ps[i].IsOptional || mainInfo.ParameterInfos[i].IsParams) { optionalInfo = new OverloadGenInfo() { ParameterInfos = constructorInfo.GetParameters().Select(info => ParameterGenInfo.FromParameterInfo(info)).Take(i).ToArray(), TypeName = constructorInfo.DeclaringType.GetFriendlyName(), IsVoid = false, EllipsisedParameters = true, }; optionalInfo.HasParams = optionalInfo.ParameterInfos.Any(info => info.IsParams); ret.Add(optionalInfo); } else { break; } } } else { throw new NotSupportedException(); } return(ret); }