public TypeViewModel(TypeInfo typeInfo)
{
_isExpanded = true;
_typeInfo = typeInfo;
if (_typeInfo.BaseType != null)
{
BaseType = new TypeViewModel(_typeInfo.BaseType);
}
_fields = _typeInfo.Fields
.OrderBy(f => f.Name)
.Select(f => new FieldViewModel(f))
.OfType<MemberViewModel>()
.ToArray();
_properties = _typeInfo.Properties
.OrderBy(p => p.Name)
.Select(p => new PropertyViewModel(p))
.OfType<MemberViewModel>()
.ToArray();
_events = _typeInfo.Events
.OrderBy(e => e.Name)
.Select(e => new EventViewModel(e))
.OfType<MemberViewModel>()
.ToArray();
_methods = _typeInfo.Methods
.OrderBy(m => m.Name)
.Select(m => new MethodViewModel(m))
.OfType<MemberViewModel>()
.ToArray();
NavigateCommand = new DelegateCommand(NavigateCommandHandler);
BrowseInteractionsCommand = new DelegateCommand(BrowseInteractionsCommandHandler);
}
public AssemblyBrowserWindowViewModel(IEnumerable<AssemblyInfo> assemblyDefinitions,
TypeInfo type,
Dispatcher dispatcher)
{
_dispatcher = dispatcher;
_assemblies = new ObservableCollection<AssemblyViewModel>(
assemblyDefinitions.Select(a => new AssemblyViewModel(a, this)));
OnAssembliesChanged();
NavigateBackCommand = new DelegateCommand(NavigateBackCommandHandler);
NavigateForwardCommand = new DelegateCommand(NavigateForwardCommandHandler);
ShowInnerSearchCommand = new DelegateCommand(ShowInnerSearchCommandHandler);
ToggleAssembliesCommand = new DelegateCommand(ToggleAssembliesCommandHandler);
RefreshNavigationCommands();
IsColorized = true;
_searchScreen = new SearchScreen(this);
if (type == null)
{
Screen = _searchScreen;
}
else
{
var typeViewModel = Types.Single(t => t.TypeInfo == type);
CurrentNavigationItem = new NavigationItem(typeViewModel);
}
}
public AncestryBrowserWindow(TypeInfo typeInfo)
{
InitializeComponent();
ViewModel = new AncestryBrowserWindowViewModel(typeInfo);
WindowManager.AddAncestryBrowser(this);
}
public static void BrowseAncestry(TypeInfo type)
{
var window = new AncestryBrowserWindow(type);
#if ILSpy
window.Owner = MainWindow;
#elif Reflector
System.Windows.Forms.Integration.ElementHost.EnableModelessKeyboardInterop(window);
#endif
window.Show();
}
public AncestryBrowserWindowViewModel(TypeInfo typeInfo)
{
_typeInfo = typeInfo;
ExpandCollapseAllCommand = new DelegateCommand(ExpandCollapseAllCommandHandler);
_options = new MemberOptions
{
ShowProperties = true,
ShowEvents = true,
ShowMethods = true,
ShowProtected = true,
ShowProtectedInternal = true,
ShowPublic = true
};
_typeViewModel = new TypeViewModel(_typeInfo);
_ancestry = _typeViewModel.Ancestry.ToList();
_ancestry.Last().IsLast = true;
_assemblies = _ancestry
.GroupBy(t => t.TypeInfo.Module.Assembly)
.Select(g => new AssemblyViewModel(g.Key, g))
.ToList();
int currentIndex = 0;
foreach (var assembly in _assemblies)
{
var brush = BrushProvider.BrushPairs[currentIndex].Background as SolidColorBrush;
brush = new SolidColorBrush(
new Color { A = 72, R = brush.Color.R, G = brush.Color.G, B = brush.Color.B});
assembly.BackgroundBrush = brush;
assembly.CaptionBrush = BrushProvider.BrushPairs[currentIndex].Caption;
currentIndex++;
if (currentIndex == BrushProvider.BrushPairs.Count)
{
currentIndex = 0;
}
}
KindGroup = new CommandsGroupViewModel(
Resources.Members,
new List<GroupedUserCommand>
{
new GroupedUserCommand(Resources.All, ShowAllMemberKinds, true),
new GroupedUserCommand(Resources.Virtual, ShowVirtualMembers)
});
UpdateMembers();
FillToolTips();
}
public AssemblyBrowserWindow(IEnumerable<AssemblyInfo> assemblies, TypeInfo typeInfo)
{
InitializeComponent();
ViewModel = new AssemblyBrowserWindowViewModel(assemblies, typeInfo, Dispatcher);
CommandBindings.Add(new CommandBinding(NavigationCommands.BrowseForward,
(s, e) => ViewModel.NavigateForwardCommand.Execute(null)));
CommandBindings.Add(new CommandBinding(NavigationCommands.BrowseBack,
(s, e) => ViewModel.NavigateBackCommand.Execute(null)));
WindowManager.AddAssemblyBrowser(this);
}
public TypeInfo Type(ITypeDeclaration type, ModuleInfo module)
{
if (type == null)
{
return null;
}
if (_typeCorrespondence.ContainsKey(type))
{
return _typeCorrespondence[type];
}
var methods = type.Methods.OfType<IMethodDeclaration>()
.Where(m => !m.Name.Contains("get_")
&& !m.Name.Contains("set_")
&& !m.Name.Contains("add_")
&& !m.Name.Contains("remove_"))
.ToArray();
var typeInfo = new TypeInfo
{
BaseTypeRetriever = () => Type(type.BaseType),
Name = type.Name,
Events = type.Events.OfType<IEventDeclaration>().Select(e => Event(e)),
Properties = type.Properties.OfType<IPropertyDeclaration>().Select(p => Property(p)),
MembersCount = methods.Count() + type.Events.Count + type.Properties.Count + type.Fields.Count,
IsInternal = type.Visibility == TypeVisibility.Private
|| type.Visibility == TypeVisibility.NestedPrivate
|| type.Visibility == TypeVisibility.NestedFamilyAndAssembly
|| type.Visibility == TypeVisibility.NestedAssembly,
IsPublic = type.Visibility == TypeVisibility.Public
|| type.Visibility == TypeVisibility.NestedPublic
|| type.Visibility == TypeVisibility.NestedFamilyOrAssembly
|| type.Visibility == TypeVisibility.NestedFamily,
MemberReference = type,
IsEnum = IsEnum(type),
IsInterface = type.Interface,
IsValueType = type.ValueType,
IsSealed = type.Sealed,
IsAbstract = type.Abstract
};
typeInfo.FullName = GetFullName(type.Namespace, typeInfo.Name);
typeInfo.Methods = methods.Select(m => Method(m, typeInfo));
typeInfo.Accessors = type.Methods.OfType<IMethodDeclaration>().Except(methods).Select(m => Method(m, typeInfo));
typeInfo.Fields = type.Fields.OfType<IFieldDeclaration>().Select(f => Field(f, typeInfo));
foreach (var eventInfo in typeInfo.Events)
{
eventInfo.DeclaringType = typeInfo;
}
foreach (var propertyInfo in typeInfo.Properties)
{
propertyInfo.DeclaringType = typeInfo;
}
_typeCorrespondence.Add(type, typeInfo);
typeInfo.Module = module ?? Module(GetModuleForType(type));
typeInfo.Icon = Images.Images.GetTypeIcon(typeInfo);
return typeInfo;
}
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 FieldInfo Field(IFieldDeclaration fieldDefinition, TypeInfo type)
{
if (_fieldCorrespondence.ContainsKey(fieldDefinition))
{
return _fieldCorrespondence[fieldDefinition];
}
var fieldInfo = new FieldInfo
{
Text = fieldDefinition.ToString(),
Name = fieldDefinition.Name,
FullName = fieldDefinition.Name,
IsInternal = fieldDefinition.Visibility == FieldVisibility.Assembly,
IsPrivate = fieldDefinition.Visibility == FieldVisibility.Private,
IsPublic = fieldDefinition.Visibility == FieldVisibility.Public,
IsProtected = fieldDefinition.Visibility == FieldVisibility.Family,
IsProtectedAndInternal = fieldDefinition.Visibility == FieldVisibility.FamilyAndAssembly,
IsProtectedOrInternal = fieldDefinition.Visibility == FieldVisibility.FamilyOrAssembly,
IsStatic = fieldDefinition.Static,
IsLiteral = fieldDefinition.Literal,
IsInitOnly = fieldDefinition.ReadOnly,
IsSpecialName = fieldDefinition.SpecialName,
MemberReference = fieldDefinition,
DeclaringType = type
};
_fieldCorrespondence.Add(fieldDefinition, fieldInfo);
fieldInfo.Text = fieldInfo.Text.Substring(fieldInfo.Text.LastIndexOf('.') + 1);
fieldInfo.Name = fieldInfo.Name.Substring(fieldInfo.Name.LastIndexOf('.') + 1);
fieldInfo.Icon = Images.Images.GetFieldIcon(fieldInfo);
return fieldInfo;
}
private TypeViewModel GetViewModelForType(TypeInfo typeInfo)
{
if (_viewModelCorrespondence.ContainsKey(typeInfo))
{
return _viewModelCorrespondence[typeInfo];
}
var viewModel = new TypeViewModel(typeInfo, this);
_viewModelCorrespondence.Add(typeInfo, viewModel);
return viewModel;
}
private HierarchyViewModel GetHierarchy(TypeInfo typeInfo)
{
var hierarchyList = new List<TypeInfo>();
var currentType = typeInfo;
hierarchyList.Add(typeInfo);
while (currentType.BaseType != null)
{
var t = currentType.BaseType;
hierarchyList.Add(t);
currentType = t;
}
return new HierarchyViewModel(hierarchyList.Select(GetViewModelForType).ToArray());
}
private IEnumerable<FieldInfo> FixDeclaringTypes(FieldInfo[] fields, TypeInfo[] types)
{
var fixedFields = new List<FieldInfo>();
var typeFullNames = types.Select(t => t.FullName).ToArray();
foreach (var field in fields)
{
if (types.Contains(field.DeclaringType))
{
fixedFields.Add(field);
continue;
}
if (typeFullNames.Contains(field.DeclaringType.FullName))
{
var type = types.Single(t => t.FullName == field.DeclaringType.FullName);
var realField = type.Fields.Single(m => m.Name == field.Name);
fixedFields.Add(realField);
}
}
return fixedFields;
}
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;
}
public TypeViewModel(TypeInfo typeInfo, AssemblyViewModel assemblyViewModel, AssemblyBrowserWindowViewModel windowViewModel)
{
_typeInfo = typeInfo;
_windowViewModel = windowViewModel;
_assemblyViewModel = assemblyViewModel;
_name = typeInfo.Name;
_fullName = typeInfo.FullName;
_extendedInfo = IsInternal
? string.Format("{0}\n{1}", FullName, Resources.Internal)
: FullName;
if (_typeInfo.IsEnum)
{
var enumValues = _typeInfo.Fields.Where(f => f.Name != "value__").Select(f => f.Name);
if (enumValues.Count() > 0)
{
var values = string.Join("\n", _typeInfo.Fields.Where(f => f.Name != "value__").Select(f => f.Name));
_extendedInfo = string.Format("{0}\n\n{1}", _extendedInfo, values);
}
}
else if (_typeInfo.IsInterface)
{
var members = _typeInfo.Events.Select(m => m.Text)
.Concat(_typeInfo.Properties.Select(p => p.Text))
.Concat(_typeInfo.Methods.Select(p => p.Text));
if (members.Count() > 0)
{
var values = string.Join("\n", members);
_extendedInfo = string.Format("{0}\n\n{1}", _extendedInfo, values);
}
}
if (HasBaseType)
{
var baseType = _typeInfo.BaseType;
_baseTypeName = baseType.Name;
_baseTypeFullName = baseType.FullName;
if (baseType == null)
{
_baseTypeFullName = _baseTypeFullName + "\n" + Resources.NotAvailable;
_isBaseTypeAvailable = false;
}
}
var properties = typeInfo.Properties
.Where(p => p.IsPublic)
.Select(p => new PropertyViewModel(p))
.OfType<MemberViewModel>();
var events = typeInfo.Events
.Where(e => e.IsPublic)
.Select(e => new EventViewModel(e))
.OfType<MemberViewModel>();
var methods = typeInfo.Methods
.Where(m => m.IsPublic)
.Select(m => new MethodViewModel(m))
.OfType<MemberViewModel>();
Members = properties.Concat(events).Concat(methods);
_membersCount = typeInfo.MembersCount;
VisualizeCommand = new DelegateCommand(VisualizeCommandHandler);
NavigateCommand = new DelegateCommand(NavigateCommandHandler);
NavigateToBaseCommand = new DelegateCommand(NavigateToBaseCommandHandler);
ShowMembersCommand = new DelegateCommand(ShowMembersCommandHandler);
BrowseAncestryCommand = new DelegateCommand(BrowseAncestryCommandHandler);
BrowseInteractionsCommand = new DelegateCommand(BrowseInteractionsCommandHandler);
ExpandCommand = new DelegateCommand(ExpandCommandHandler);
RefreshBackground();
ResetName();
}
