/// <summary>Gets the generic instanced type information</summary> /// <param name="hash">The hashtable to change the generics into the instanced generics</param> /// <param name="info">The information of the type to look into, should be the original</param> /// <param name="ninfo">The information of the type to look into, should be generic instanced</param> /// <param name="isGeneric">Set to true if anything was changed by this method</param> /// <returns>Returns a quick look into the typing</returns> public static QuickTypeInfo GetGenericInstanceTypeInfo( Dictionary <string, QuickTypeInfo> hash, QuickTypeInfo info, QuickTypeInfo ninfo, out bool isGeneric ) { isGeneric = false; foreach (string key in hash.Keys) { // Variables string arrayPattern = $@"{ key }((?:\[,*\])+)"; if (info.unlocalizedName == key) { info.unlocalizedName = hash[key].unlocalizedName; } if (info.unlocalizedName.Contains('.')) { info.namespaceName = Regex.Replace(info.unlocalizedName, @"(.*)\..*$", "$1"); } else { info.namespaceName = ""; } if (info.fullName == key) { info.fullName = hash[key].fullName; isGeneric = true; } else if (info.fullName.Contains(key)) { // Variables string genericPattern = $@"([<,]){ key }([>,])"; info.fullName = Regex.Replace( info.fullName, genericPattern, $"$1{ hash[key].fullName }$2" ); info.fullName = Regex.Replace( info.fullName, arrayPattern, $"{ hash[key].fullName }$1" ); isGeneric = true; } } if (isGeneric) { info.name = QuickTypeInfo.DeleteNamespaceFromType( QuickTypeInfo.MakeNameFriendly(info.fullName) ); } if (info.fullName == info.name) { // Variables string arrayPattern = $@"[a-zA-Z0-9]+((?:\[,*\])+)"; info.fullName = Regex.Replace( info.fullName, arrayPattern, $"{ info.unlocalizedName }$1" ); } info.isGenericType = isGeneric && (info.unlocalizedName == info.nonInstancedFullName); return(info); }
/// <summary>Generates a generic instance of the method</summary> /// <param name="method">The method to look into</param> /// <param name="methodRef">The method reference to look into</param> /// <returns>Returns the information into the method</returns> public static MethodInfo GenerateInfo(MethodDefinition method, MethodReference methodRef) { // Variables QuickTypeInfo ninfo = QuickTypeInfo.GenerateInfo(methodRef.DeclaringType); MethodInfo info = GenerateInfo(method); Dictionary <string, QuickTypeInfo> hash = new Dictionary <string, QuickTypeInfo>(); bool isGeneric = false; int i = 0; foreach (GenericParametersInfo generic in info.implementedType.genericParameters) { // Variables QuickTypeInfo temp = new QuickTypeInfo(); temp.unlocalizedName = ninfo.genericParameters[i].unlocalizedName; temp.fullName = ninfo.genericParameters[i].name; temp.name = QuickTypeInfo.DeleteNamespaceFromType(QuickTypeInfo.MakeNameFriendly(temp.fullName)); if (temp.unlocalizedName.Contains('.')) { temp.namespaceName = Regex.Replace(temp.unlocalizedName, @"(.*)\..*$", "$1"); } else { temp.namespaceName = ""; } hash.Add(generic.name, temp); i++; } foreach (ParameterInfo parameter in info.parameters) { parameter.typeInfo = GetGenericInstanceTypeInfo(hash, parameter.typeInfo, ninfo, out isGeneric); if (isGeneric) { parameter.typeInfo.genericParameters = GenericParametersInfo.GenerateInfoArray(methodRef.Resolve().DeclaringType.GenericParameters); parameter.genericParameterDeclarations = QuickTypeInfo.GetGenericParametersAsStrings(parameter.typeInfo.fullName); parameter.fullDeclaration = ParameterInfo.GetFullDeclaration(parameter); } } info.returnType = GetGenericInstanceTypeInfo( hash, info.returnType, QuickTypeInfo.GenerateInfo(methodRef.ReturnType), out isGeneric ); info.declaration = ( info.accessor + " " + (info.modifier != "" ? info.modifier + " " : "") + (!info.isConstructor && !info.isConversionOperator ? info.returnType.name + " " : "") + (!info.isConversionOperator ? info.name : info.returnType.name) ); info.genericDeclaration = (info.genericParameters.Length > 0 && !method.IsGenericInstance ? $"<{ string.Join(',', GetGenericParameterDeclaration(info.genericParameters)) }>" : "" ); info.parameterDeclaration = string.Join(", ", GetParameterDeclaration(info)); if (info.isExtension) { info.parameterDeclaration = $"this { info.parameterDeclaration }"; } info.fullDeclaration = $"{ info.declaration }{ info.genericDeclaration }({ info.parameterDeclaration })"; info.fullDeclaration += TypeInfo.GetGenericParameterConstraints(info.genericParameters); return(info); }