public static bool MethodsMatch(MethodInfo method1, MethodInfo method2)
{
#if ILSpy
var md1 = method1.MemberReference as MethodDefinition;
var md2 = method2.MemberReference as MethodDefinition;
return md1.Name == md2.Name && ParametersMatch(md1, md2);
#elif Reflector
var md1 = method1.MemberReference as IMethodDeclaration;
var md2 = method2.MemberReference as IMethodDeclaration;
//return md1.Name == md2.Name && ParametersMatch(md1, md2);
return method1.Text == method2.Text;
#else
return false;
#endif
}
public MethodInfo Method(IMethodDeclaration method, TypeInfo type)
{
if (_methodCorrespondence.ContainsKey(method))
{
return _methodCorrespondence[method];
}
var methodInfo = new MethodInfo
{
Text = method.ToString(),
Name = method.Name,
FullName = method.Name,
IsInternal = method.Visibility == MethodVisibility.Assembly,
IsPrivate = method.Visibility == MethodVisibility.Private,
IsPublic = method.Visibility == MethodVisibility.Public,
IsProtected = method.Visibility == MethodVisibility.Family,
IsProtectedAndInternal = method.Visibility == MethodVisibility.FamilyAndAssembly,
IsProtectedOrInternal = method.Visibility == MethodVisibility.FamilyOrAssembly,
IsVirtual = method.Virtual,
IsOverride = method.Virtual && !method.NewSlot,
IsSpecialName = method.SpecialName,
IsStatic = method.Static,
IsFinal = method.Final,
MemberReference = method,
DeclaringType = type
};
_methodCorrespondence.Add(method, methodInfo);
if (method.Overrides.Count > 0)
{
var overridden = method.Overrides[0];
var declaringType = overridden.DeclaringType as ITypeReference;
if (declaringType.Resolve().Interface)
{
methodInfo.IsOverride = false;
}
}
int correction = methodInfo.Text.Contains(".ctor") || methodInfo.Text.Contains(".cctor") ? 0 : 1;
methodInfo.Text = methodInfo.Text.Substring(methodInfo.Text.LastIndexOf('.') + correction);
methodInfo.Name = methodInfo.Name.Substring(methodInfo.Name.LastIndexOf('.') + correction);
methodInfo.Icon = Images.Images.GetMethodIcon(methodInfo);
return methodInfo;
}
public MethodViewModel(MethodInfo methodInfo)
: base(methodInfo)
{
_methodInfo = methodInfo;
}
private TypeViewModel GetTypeInAncestryWithMethod(MethodInfo methodInfo)
{
if (_methods.Any(m => Services.MethodsMatch(methodInfo, m.MemberInfo as MethodInfo)))
{
return this;
}
if (BaseType != null)
{
return BaseType.GetTypeInAncestryWithMethod(methodInfo);
}
throw new ArgumentException("No type with such method text in ancestry");
}
private MemberViewModel GetViewModelForMethod(MethodInfo methodInfo)
{
MemberViewModel vm;
if (_viewModelsDictionary.ContainsKey(methodInfo))
{
var typeViewModel = GetViewModelForType(methodInfo.DeclaringType);
vm = _viewModelsDictionary[methodInfo];
vm.Background = typeViewModel.Background;
vm.Foreground = typeViewModel.Foreground;
return vm;
}
if (IsPropertyAccessor(methodInfo))
{
var propertyInfo = Helper.GetAccessorProperty(methodInfo.MemberReference);
var typeViewModel = GetViewModelForType(propertyInfo.DeclaringType);
if (_viewModelsDictionary.ContainsKey(propertyInfo))
{
vm = _viewModelsDictionary[propertyInfo];
vm.Background = typeViewModel.Background;
vm.Foreground = typeViewModel.Foreground;
return vm;
}
var pvm = new PropertyViewModel(propertyInfo)
{
Background = typeViewModel.Background,
Foreground = typeViewModel.Foreground,
ToolTip = typeViewModel.Name
};
_viewModelsDictionary.Add(propertyInfo, pvm);
return pvm;
}
if (IsEventAccessor(methodInfo))
{
var eventInfo = Helper.GetAccessorEvent(methodInfo.MemberReference);
var typeViewModel = GetViewModelForType(eventInfo.DeclaringType);
if (_viewModelsDictionary.ContainsKey(eventInfo))
{
vm = _viewModelsDictionary[eventInfo];
vm.Background = typeViewModel.Background;
vm.Foreground = typeViewModel.Foreground;
return vm;
}
var evm = new EventViewModel(eventInfo)
{
Background = typeViewModel.Background,
Foreground = typeViewModel.Foreground,
ToolTip = typeViewModel.Name
};
_viewModelsDictionary.Add(eventInfo, evm);
return evm;
}
var tvm = GetViewModelForType(methodInfo.DeclaringType);
var mvm = new MethodViewModel(methodInfo)
{
Background = tvm.Background,
Foreground = tvm.Foreground,
ToolTip = tvm.Name
};
_viewModelsDictionary.Add(methodInfo, mvm);
return mvm;
}
private IEnumerable<MethodInfo> FixDeclaringTypes(MethodInfo[] methods, TypeInfo[] types)
{
var fixedMethods = new List<MethodInfo>();
var typeFullNames = types.Select(t => t.FullName).ToArray();
foreach (var method in methods)
{
if (types.Contains(method.DeclaringType))
{
fixedMethods.Add(method);
continue;
}
if (typeFullNames.Contains(method.DeclaringType.FullName))
{
var type = types.Single(t => t.FullName == method.DeclaringType.FullName);
var realMethod = type.Methods.SingleOrDefault(m => m.MemberReference.ToString() == method.MemberReference.ToString());
if (realMethod == null)
{
realMethod = type.Accessors.Single(m => m.MemberReference.ToString() == method.MemberReference.ToString());
}
fixedMethods.Add(realMethod);
}
}
return fixedMethods;
}
private static bool IsPropertyAccessor(MethodInfo method)
{
return (method.IsSpecialName
&& (method.Name.IndexOf("get_") != -1 || method.Name.IndexOf("set_") != -1));
}
private static bool IsEventAccessor(MethodInfo method)
{
return (method.IsSpecialName
&& (method.Name.IndexOf("add_") != -1 || method.Name.IndexOf("remove_") != -1));
}
