private MethodInfo GetOriginalMethod(Type T, string MethodName, bool SearchOnlyInGeneric, bool Strict, bool UsePotential, out Dictionary <string, string> GenericMap, params string[] TypeName)
{
Func <string, string, bool> CheckCaseSensitive; Func <string, string, bool> Check; Func <MethodInfo, bool> CheckParams;
string[] typeName; string methodName; MethodInfo[] methods; MethodInfo Result;
if (SearchOnlyInGeneric)
{
methods = T.GetMethods().Where(S => S.ContainsGenericParameters).ToArray();
}
else
{
methods = T.GetMethods();
}
if (Strict)
{
methodName = MethodName; typeName = TypeName;
CheckCaseSensitive = (ParamName, CheckName) => ParamName == CheckName;
Check = (ParamName, CheckName) => ParamName != CheckName;
}
else
{
methodName = MethodName.ToUpper(); typeName = TypeName.Select(x => x.ToUpper()).ToArray();
CheckCaseSensitive = (ParamName, CheckName) =>
ParamName.ToUpper() == CheckName;
Check = (ParamName, CheckName) =>
!ParamName.ToUpper().Contains(CheckName);
}
Dictionary <string, string> GM = null;
if (UsePotential)
{
CheckParams = M =>
Similar(M, Strict, ref GM, typeName);
}
else
{
CheckParams = M =>
M.GetParameters().Where((P, i) => Check(P.ParameterType.FullName, typeName[i])).FirstOrDefault() == null;
}
Result = methods.Select(M => new { Method = M, Prs = M.GetParameters() }).Where(M => (
(CheckCaseSensitive(M.Method.Name, methodName)) &&
(M.Prs.Length == typeName.Length) &&
CheckParams(M.Method)
)).Select(M => M.Method).FirstOrDefault();
GenericMap = GM;
return(Result);
}
private bool Similar(MethodInfo method, bool Strict, ref Dictionary <string, string> GenericMap, params string[] TypeName)
{
Func <string, string> NoStrict = ParamName =>
{
string S = ParamName.ToUpper();
foreach (var C in CH)
{
S = S.Replace(C.Key, C.Value);
}
// Replace("SYSTEM.COLLECTIONS.GENERIC.", "").Replace("SYSTEM.", "").Replace("`1[", "[").Replace("`2[", "[")
return(S);
};
Func <string, string> CheckStrict = ParamName => Strict ? ParamName : NoStrict(ParamName);
string[] Name = method.GetParameters().Select(x => CheckStrict(x.ParameterType.ToString())).ToArray();
int L = Name.Length; bool Result = false;
if (L == TypeName.Length)
{
Dictionary <string, string> GenericName =
(Dictionary <string, string>)method.GetGenericArguments().Select(x => x.ToString()).ToDictionary(x => Strict ? x : x.ToUpper(), x => string.Empty);
string[] typeName;
if (Strict)
{
typeName = TypeName;
}
else
{
typeName = TypeName.Select(x => NoStrict(x)).ToArray();
}
Func <string, string, bool> SameText = ((NameType, NameGeneric) =>
{
if (Strict)
{
return(NameType == NameGeneric);
}
return(NameGeneric.Contains(NameType));
});
Func <string, string, bool> PossibleTranslateInGeneric = ((NameType, NameGeneric) =>
{
if (!GenericName.ContainsKey(NameGeneric))
{
return(false);
}
string TT = GenericName[NameGeneric];
if (TT == NameType)
{
return(true);
}
else if (TT == string.Empty)
{
GenericName[NameGeneric] = NameType; return(true);
}
else
{
return(false);
}
});
Func <string, string> DT3 = (NameGenericMod =>
{
GenericName.Select(x => x.Key).ToList().ForEach(y =>
{
NameGenericMod = NameGenericMod.Replace(y + ",", GenericName[y] + ",");
});
return(NameGenericMod);
});
Result = typeName.Select((t, i) => new
{
ParamsType = SimpleTypes(t),
ParamsGen = SimpleTypes(Name[i])
}).Where(t => (
(t.ParamsType.Length != t.ParamsGen.Length) ||
!(t.ParamsType.Where((x, i) => (!(SameText(x, t.ParamsGen[i]) ||
PossibleTranslateInGeneric(x, t.ParamsGen[i])))).FirstOrDefault() == null)
//|| (t.s1 != DT3(t.s2))
)).FirstOrDefault() == null;
if (Result)
{
if (Strict)
{
GenericMap = GenericName;
}
else
{
GenericMap = method.GetGenericArguments().ToDictionary(x => x.ToString(), x => string.Empty);
for (int i = 0; i < GenericMap.Count; i++)
{
GenericMap[GenericMap.ElementAt(i).Key] = this.GetFullNameClass(GenericName[GenericName.ElementAt(i).Key]);
}
}
}
}
return(Result);
}
