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);
}
