public static void SearchMsdn(ILSpyTreeNode node) { var address = string.Empty; var namespaceNode = node as NamespaceTreeNode; if (namespaceNode != null) address = string.Format(msdnAddress, namespaceNode.Name); var memberNode = node as IMemberTreeNode; if (memberNode != null) { var member = memberNode.Member; var memberName = string.Empty; if (member.DeclaringType == null) memberName = member.FullName; else memberName = string.Format("{0}.{1}", member.DeclaringType.FullName, member.Name); address = string.Format(msdnAddress, memberName); } address = address.ToLower(); if (!string.IsNullOrEmpty(address)) Process.Start(address); }
static void Execute(ILSpyTreeNode[] nodes) { if (!AddNetModuleToAssemblyCommand.CanExecute(nodes)) return; var dialog = new System.Windows.Forms.OpenFileDialog() { Filter = ".NET NetModules (*.netmodule)|*.netmodule|All files (*.*)|*.*", RestoreDirectory = true, }; if (dialog.ShowDialog() != System.Windows.Forms.DialogResult.OK) return; if (string.IsNullOrEmpty(dialog.FileName)) return; var asm = new LoadedAssembly(MainWindow.Instance.CurrentAssemblyList, dialog.FileName); if (asm.ModuleDefinition == null || asm.AssemblyDefinition != null) { MainWindow.Instance.ShowMessageBox(string.Format("{0} is not a NetModule", asm.FileName), System.Windows.MessageBoxButton.OK); asm.TheLoadedFile.Dispose(); return; } var cmd = new AddExistingNetModuleToAssemblyCommand((AssemblyTreeNode)nodes[0], asm); UndoCommandManager.Instance.Add(cmd); MainWindow.Instance.JumpToReference(cmd.modNode); }
public void Inject(ICSharpCode.ILSpy.TreeNodes.ILSpyTreeNode node, string name, IMetadataTokenProvider member) { //Name and namespace var typeName = node is ModuleTreeNode ? (name.Substring(name.Contains(".") ? name.LastIndexOf('.') + 1 : 0)) : name; var typeNamespace = node is ModuleTreeNode ? (name.Substring(0, name.Contains(".") ? name.LastIndexOf('.') : 0)) : string.Empty; //Checks that the typename isn't empty if (string.IsNullOrEmpty(typeName)) { MessageBox.Show("Please, specify the name of the type", "Type name required", MessageBoxButton.OK, MessageBoxImage.Error); return; } //Creates a new class definition var c = new TypeDefinition( typeNamespace, typeName, TypeAttributes.Class | TypeAttributes.Interface | TypeAttributes.Public | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.Abstract ) { IsAnsiClass = true, }; //Adds to the node Helpers.Tree.AddTreeNode(node, c, null, null); }
public void Inject(ICSharpCode.ILSpy.TreeNodes.ILSpyTreeNode node, string name, IMetadataTokenProvider member) { //Name and namespace var typeName = node is ModuleTreeNode ? (name.Substring(name.Contains(".") ? name.LastIndexOf('.') + 1 : 0)) : name; var typeNamespace = node is ModuleTreeNode ? (name.Substring(0, name.Contains(".") ? name.LastIndexOf('.') : 0)) : string.Empty; //Checks that the typename isn't empty if (string.IsNullOrEmpty(typeName)) { MessageBox.Show("Please, specify the name of the type", "Type name required", MessageBoxButton.OK, MessageBoxImage.Error); return; } //Creates a new class definition var c = new TypeDefinition( typeNamespace, typeName, TypeAttributes.Class | TypeAttributes.SequentialLayout | TypeAttributes.Sealed | TypeAttributes.Public ); //Adds the type Helpers.Tree.AddTreeNode(node, c, module => { c.BaseType = module.Import(new TypeReference("System", "ValueType", module, module.TypeSystem.Corlib, true)); }, type => { c.BaseType = type.Module.Import(new TypeReference("System", "ValueType", type.Module, type.Module.TypeSystem.Corlib, true)); } ); }
public void Inject(ICSharpCode.ILSpy.TreeNodes.ILSpyTreeNode node, string name, IMetadataTokenProvider member) { //Type var type = ((IMemberTreeNode)node).Member as TypeDefinition; //Creates the method definition var method = new MethodDefinition( name, MethodAttributes.Public, type.Module.TypeSystem.Void ) { MetadataToken = new MetadataToken(TokenType.Method, ILEdit.GlobalContainer.GetFreeRID(type.Module)) }; //Checks if the destination type is an interface if (type.IsInterface) { method.Attributes |= MethodAttributes.NewSlot | MethodAttributes.CheckAccessOnOverride | MethodAttributes.Abstract | MethodAttributes.Virtual; } //Adds the method to the type type.Methods.Add(method); method.Overrides.Clear(); if (node is TypeTreeNode) { node.Children.Add(new ILEditTreeNode(method, false)); Helpers.Tree.SortChildren((TypeTreeNode)node); } else if (node is ILEditTreeNode) { ((ILEditTreeNode)node).RefreshChildren(); } }
static void Execute(ILSpyTreeNode[] nodes) { if (!CanExecute(nodes)) return; var nsNodes = nodes.Select(a => (NamespaceTreeNode)a).ToArray(); UndoCommandManager.Instance.Add(new DeleteNamespaceCommand(nsNodes)); }
public static void SearchMsdn(ILSpyTreeNode node) { var address = string.Empty; var namespaceNode = node as NamespaceTreeNode; if (namespaceNode != null) address = string.Format(msdnAddress, namespaceNode.Name); var memberNode = node as IMemberTreeNode; if (memberNode != null) { var member = memberNode.Member; var memberName = string.Empty; ITypeDefOrRef declType = null; if (member is IDefinition) declType = ((IDefinition)member).DeclaringType; else if (declType is IField) declType = ((IField)member).DeclaringType; else if (declType is IMethod) declType = ((IMethod)member).DeclaringType; if (declType == null) memberName = member.FullName; else memberName = string.Format("{0}.{1}", declType.FullName, member.Name); address = string.Format(msdnAddress, memberName); } address = address.ToLower(); if (!string.IsNullOrEmpty(address)) Process.Start(address); }
public void Inject(ICSharpCode.ILSpy.TreeNodes.ILSpyTreeNode node, string name, IMetadataTokenProvider member) { //Type var type = (TypeDefinition)((IMemberTreeNode)node).Member; //Creates the field definition var field = new FieldDefinition( name, FieldAttributes.Public, type.Module.Import((TypeReference)member, type) ) { MetadataToken = new MetadataToken(TokenType.Field, ILEdit.GlobalContainer.GetFreeRID(type.Module)) }; //Adds the field to the type type.Fields.Add(field); if (node is TypeTreeNode) { node.Children.Add(new ILEditTreeNode(field, true)); Helpers.Tree.SortChildren((TypeTreeNode)node); } else if (node is ILEditTreeNode) { ((ILEditTreeNode)node).RefreshChildren(); } }
SharpTreeNode IRenamerContextMenu.FindRenamedNode(ILSpyTreeNode oldNode, string[] path, string oldName, object targetObject) { var newName = RenameHelper.GetName(targetObject); RenamePath(oldNode, path, oldName, newName); return MainWindow.Instance.FindNodeByPath(path, true); }
protected override void Initialize(ILSpyTreeNode[] nodes, MenuItem menuItem) { if (nodes.Length == 1) menuItem.Header = string.Format("Remove {0}", UIUtils.EscapeMenuItemHeader(nodes[0].ToString())); else menuItem.Header = string.Format("Remove {0} assemblies", nodes.Length); }
internal static void Execute(ILSpyTreeNode[] nodes, uint[] offsets = null) { if (!CanExecute(nodes)) return; var methodNode = (MethodTreeNode)nodes[0]; var module = ILSpyTreeNode.GetModule(nodes[0]); Debug.Assert(module != null); if (module == null) throw new InvalidOperationException(); var data = new MethodBodyVM(new MethodBodyOptions(methodNode.MethodDefinition), module, MainWindow.Instance.CurrentLanguage, methodNode.MethodDefinition.DeclaringType, methodNode.MethodDefinition); var win = new MethodBodyDlg(); win.DataContext = data; win.Owner = MainWindow.Instance; win.Title = string.Format("{0} - {1}", win.Title, methodNode.ToString()); if (data.IsCilBody && offsets != null) data.CilBodyVM.Select(offsets); if (win.ShowDialog() != true) return; UndoCommandManager.Instance.Add(new MethodBodySettingsCommand(methodNode, data.CreateMethodBodyOptions())); }
static DnSpyFileList GetDnSpyFileList(ILSpyTreeNode node) { if (node == null) return null; var asmNode = GetNode<AssemblyTreeNode>(node); if (asmNode == null) return null; return asmNode.DnSpyFileList; }
public bool CanInjectInNode(ICSharpCode.ILSpy.TreeNodes.ILSpyTreeNode node) { //Try-cast var memberNode = node as IMemberTreeNode; var type = memberNode == null ? null : (memberNode.Member as TypeDefinition); //Can inject only in types (except interfaces) return(type != null && !type.IsInterface); }
public void Inject(ICSharpCode.ILSpy.TreeNodes.ILSpyTreeNode node, string name, IMetadataTokenProvider member) { //Gets the parent module var moduleNode = Helpers.Tree.GetModuleNode(node); //Injects the assembly reference moduleNode.Module.AssemblyReferences.Add(AssemblyNameReference.Parse(name)); //Adds the node node.Children.Add(new AssemblyReferenceTreeNode(AssemblyNameReference.Parse(name), Helpers.Tree.GetAssemblyNode(moduleNode)) { Foreground = GlobalContainer.NewNodesBrush }); Helpers.Tree.SortChildren((ReferenceFolderTreeNode)node); }
static void Execute(ILSpyTreeNode[] nodes) { if (!CanExecute(nodes)) return; var win = new NetModuleOptionsDlg(); var data = new NetModuleOptionsVM(); win.DataContext = data; win.Owner = MainWindow.Instance; if (win.ShowDialog() != true) return; var cmd = new CreateNetModuleCommand(data.CreateNetModuleOptions()); UndoCommandManager.Instance.Add(cmd); MainWindow.Instance.JumpToReference(cmd.asmNodeCreator.AssemblyTreeNode); }
public bool CanInjectInNode(ICSharpCode.ILSpy.TreeNodes.ILSpyTreeNode node) { //Try-cast var memberNode = node as IMemberTreeNode; var type = memberNode == null ? null : (memberNode.Member as TypeDefinition); //Can inject only in modules and other existing types (except enums and interfaces) return (node is ModuleTreeNode || (memberNode != null && type != null && !type.IsEnum && !type.IsInterface )); }
private static void RenamePath(ILSpyTreeNode node, string[] path, string oldName, string newName) { if (node is TypeTreeNode) { string oldns; TypeParts(oldName, out oldns, out oldName); string newns; TypeParts(newName, out newns, out newName); if (path.Length > 1) path[path.Length - 2] = path[path.Length - 2].Replace(oldns, newns); } if (path.Length > 0) path[path.Length - 1] = path[path.Length - 1].Replace(oldName, newName); }
public PropertyTreeNode(PropertyDef property, ILSpyTreeNode owner) { if (property == null) throw new ArgumentNullException("property"); this.property = property; var list = GetDnSpyFileList(owner ?? this); using (list == null ? null : list.DisableAssemblyLoad()) { this.isIndexer = property.IsIndexer(); } if (property.GetMethod != null) this.Children.Add(new MethodTreeNode(property.GetMethod)); if (property.SetMethod != null) this.Children.Add(new MethodTreeNode(property.SetMethod)); if (property.HasOtherMethods) { foreach (var m in property.OtherMethods) this.Children.Add(new MethodTreeNode(m)); } }
void ApplyFilterToChild(ILSpyTreeNode child) { FilterResult r; if (this.FilterSettings == null) { r = FilterResult.Match; } else { r = child.Filter(this.FilterSettings); } switch (r) { case FilterResult.Hidden: child.IsHidden = true; break; case FilterResult.Match: child.FilterSettings = StripSearchTerm(this.FilterSettings); child.IsHidden = false; if (child.childrenNeedFiltering && child.Children.Count > 0) { child.EnsureChildrenFiltered(); } break; case FilterResult.Recurse: child.FilterSettings = this.FilterSettings; child.EnsureChildrenFiltered(); child.IsHidden = child.Children.All(c => c.IsHidden); break; case FilterResult.MatchAndRecurse: child.FilterSettings = StripSearchTerm(this.FilterSettings); child.EnsureChildrenFiltered(); child.IsHidden = child.Children.All(c => c.IsHidden); break; default: throw new InvalidEnumArgumentException(); } }
HashSet<IUndoObject> GetAssemblyNodes(ILSpyTreeNode[] nodes) { var hash = new HashSet<IUndoObject>(); if (nodes.Length == 0) { var hex = MainWindow.Instance.ActiveTabState as HexTabState; if (hex != null) { var doc = hex.HexBox.Document as AsmEdHexDocument; if (doc != null) hash.Add(UndoCommandManager.Instance.GetUndoObject(doc)); } } foreach (var node in nodes) { var asmNode = ILSpyTreeNode.GetNode<AssemblyTreeNode>(node); if (asmNode == null) continue; bool added = false; if (asmNode.DnSpyFile.ModuleDef != null) { var uo = UndoCommandManager.Instance.GetUndoObject(asmNode.DnSpyFile); if (UndoCommandManager.Instance.IsModified(uo)) { hash.Add(uo); added = true; } } var doc = HexDocumentManager.Instance.TryGet(asmNode.DnSpyFile.Filename); if (doc != null) { var uo = UndoCommandManager.Instance.GetUndoObject(doc); if (UndoCommandManager.Instance.IsModified(uo)) { hash.Add(uo); added = true; } } // If nothing was modified, just include the selected module if (!added && asmNode.DnSpyFile.ModuleDef != null) hash.Add(UndoCommandManager.Instance.GetUndoObject(asmNode.DnSpyFile)); } return hash; }
public static ILSpyTreeNode Create(string key, object data) { ILSpyTreeNode result = null; foreach (var factory in App.ExportProvider.GetExportedValues <IResourceNodeFactory>()) { result = factory.CreateNode(key, data); if (result != null) { return(result); } } var streamData = data as Stream; if (streamData != null) { result = new ResourceEntryNode(key, data as Stream); } return(result); }
SharpTreeNode IRenamerContextMenu.FindRenamedNode(ILSpyTreeNode oldNode, string[] path, string oldName, object targetObject) { // After renaming an assembly, ILSpy is still using the filename to display node text, even if assembly name changed var newNode = MainWindow.Instance.FindNodeByPath(path, true); if (newNode == null) return null; // Hack, so we have to change the shortname, without changing the filename, so that the user can reload the previous state var adef = targetObject as AssemblyDefinition; if (!(newNode is AssemblyTreeNode) || adef == null) return newNode; var la = (newNode as AssemblyTreeNode).LoadedAssembly; var pInfo = la.GetType().GetField("shortName", BindingFlags.Instance | BindingFlags.NonPublic); if (pInfo == null) return newNode; pInfo.SetValue(la, adef.Name.Name); newNode.RaisePropertyChanged("Text"); return newNode; }
public void Inject(ICSharpCode.ILSpy.TreeNodes.ILSpyTreeNode node, string name, IMetadataTokenProvider member) { //Name and namespace var typeName = node is ModuleTreeNode ? (name.Substring(name.Contains(".") ? name.LastIndexOf('.') + 1 : 0)) : name; var typeNamespace = node is ModuleTreeNode ? (name.Substring(0, name.Contains(".") ? name.LastIndexOf('.') : 0)) : string.Empty; //Checks that the typename isn't empty if (string.IsNullOrEmpty(typeName)) { MessageBox.Show("Please, specify the name of the type", "Type name required", MessageBoxButton.OK, MessageBoxImage.Error); return; } //Creates a new class definition var c = new TypeDefinition( typeNamespace, typeName, TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.Sealed ) { IsAnsiClass = true, }; //Destination module ModuleDefinition module = null; //Adds to the node and specifies the base class Helpers.Tree.AddTreeNode(node, c, m => { module = m; c.BaseType = new TypeReference("System", "Enum", m, m.TypeSystem.Corlib, true); }, t => { module = t.Module; c.BaseType = new TypeReference("System", "Enum", t.Module, t.Module.TypeSystem.Corlib, true); } ); //Injects the field value___ c.Fields.Add(new FieldDefinition( "value__", FieldAttributes.Public | FieldAttributes.SpecialName | FieldAttributes.RTSpecialName, module.TypeSystem.Int32 )); }
internal static bool View(ILSpyTreeNode node, DecompilerTextView textView, Stream stream, string name) { if (stream == null || stream.Length >= DecompilerTextView.DefaultOutputLengthLimit) { return(false); } stream.Position = 0; FileType type = GuessFileType.DetectFileType(stream); if (type == FileType.Binary) { return(false); } stream.Position = 0; AvalonEditTextOutput output = new AvalonEditTextOutput(); output.Write(FileReader.OpenStream(stream, Encoding.UTF8).ReadToEnd(), TextTokenType.Text); string ext; if (type == FileType.Xml) { ext = ".xml"; } else { try { ext = Path.GetExtension(DecompilerTextView.CleanUpName(name)); } catch (ArgumentException) { ext = ".txt"; } } textView.ShowNode(output, node, HighlightingManager.Instance.GetDefinitionByExtension(ext)); return(true); }
public InjectWindowViewModel(ILSpyTreeNode node, Window window, bool canInjectExisting) { //Stores the given parameters _node = node; _window = window; InjectExistingEnabled = canInjectExisting; //Loads the injectors Injectors = GlobalContainer.Injectors.Where(x => x.CanInjectInNode(node)).ToArray(); //Writes data for the header InjectInIcon = (ImageSource)node.Icon; InjectInContent = node.Text; //Finds the module var moduleNode = Helpers.Tree.GetModuleNode(node); DestinationModule = moduleNode == null ? null : moduleNode.Module; //Finds the enclosing type (if any) EnclosingType = Helpers.Tree.GetType(node); //Prepares the filters for the inject existing part if (canInjectExisting) { ExistingMemberFilter = node is ModuleTreeNode ? MemberFilters.Types : null; ExistingSelectableMembers = node is ModuleTreeNode ? new[] { TokenType.TypeDef } : new[] { TokenType.TypeDef, TokenType.Field, TokenType.Property, TokenType.Method, TokenType.Event }; } //Prepares the commands _InjectCommand = new RelayCommand(InjectCommandImpl); //Loads from the settings the values of the properties of the 'existing' part var settings = GlobalContainer.InjectionSettings.Element("InjectExistingSettings"); ExistingPreview = bool.Parse(settings.Attribute("Preview").Value); ExistingImportAsNestedTypesEnabled = !(node is ModuleTreeNode); ExistingImportAsNestedTypes = ExistingImportAsNestedTypesEnabled && bool.Parse(settings.Attribute("ImportAsNestedTypes").Value); }
public static void SearchMsdn(ILSpyTreeNode node) { var address = string.Empty; var namespaceNode = node as NamespaceTreeNode; if (namespaceNode != null) { address = string.Format(msdnAddress, namespaceNode.Name); } var memberNode = node as IMemberTreeNode; if (memberNode != null) { var member = memberNode.Member; var memberName = string.Empty; if (member.DeclaringType == null) { memberName = member.FullName; } else { memberName = string.Format("{0}.{1}", member.DeclaringType.FullName, member.Name); } address = string.Format(msdnAddress, memberName); } address = address.ToLower(); if (!string.IsNullOrEmpty(address)) { Process.Start(address); } }
internal static bool CanExecute(ILSpyTreeNode[] nodes) { return nodes.Length > 0 && nodes.All(n => n is PropertyTreeNode); }
static void Execute(ILSpyTreeNode[] nodes) { if (!CanExecute(nodes)) return; var ownerNode = nodes[0]; if (!(ownerNode is TypeTreeNode)) ownerNode = (ILSpyTreeNode)ownerNode.Parent; var typeNode = ownerNode as TypeTreeNode; Debug.Assert(typeNode != null); if (typeNode == null) throw new InvalidOperationException(); var module = ILSpyTreeNode.GetModule(typeNode); Debug.Assert(module != null); if (module == null) throw new InvalidOperationException(); bool isInstance = !(typeNode.TypeDefinition.IsAbstract && typeNode.TypeDefinition.IsSealed); var options = PropertyDefOptions.Create(module, "MyProperty", isInstance); var data = new PropertyOptionsVM(options, module, MainWindow.Instance.CurrentLanguage, typeNode.TypeDefinition); var win = new PropertyOptionsDlg(); win.Title = "Create Property"; win.DataContext = data; win.Owner = MainWindow.Instance; if (win.ShowDialog() != true) return; UndoCommandManager.Instance.Add(new CreatePropertyDefCommand(typeNode, data.CreatePropertyDefOptions())); }
protected override bool CanExecuteInternal(ILSpyTreeNode[] nodes) { return PropertyDefSettingsCommand.CanExecute(nodes); }
static bool CanExecute(ILSpyTreeNode[] nodes) { return nodes.Length == 1 && nodes[0] is PropertyTreeNode; }
protected override void Initialize(ILSpyTreeNode[] nodes, MenuItem menuItem) { DeletePropertyDefCommand.Initialize(nodes, menuItem); }
protected override bool CanExecuteInternal(ILSpyTreeNode[] nodes) { return DeletePropertyDefCommand.CanExecute(nodes); }
public void Inject(ICSharpCode.ILSpy.TreeNodes.ILSpyTreeNode node, string name, Mono.Cecil.IMetadataTokenProvider member) { //Type var type = (TypeDefinition)((IMemberTreeNode)node).Member; //Event type var eventType = type.Module.Import((TypeReference)member, type); //Creates the event var evt = new EventDefinition(name, EventAttributes.None, eventType) { MetadataToken = new MetadataToken(TokenType.Event, GlobalContainer.GetFreeRID(type.Module)) }; //Creates the field FieldReference backingField = null; if (!type.IsInterface) { backingField = new FieldDefinition( name, FieldAttributes.Private, eventType ) { MetadataToken = new MetadataToken(TokenType.Field, GlobalContainer.GetFreeRID(type.Module)) }; type.Fields.Add((FieldDefinition)backingField); } //Checks if the type is generic if (type.HasGenericParameters) { var giType = new GenericInstanceType(type); foreach (var x in type.GenericParameters) { giType.GenericArguments.Add(x); } backingField = new FieldReference(backingField.Name, eventType, giType); } //Creates the addon method evt.AddMethod = new MethodDefinition( "add_" + name, MethodAttributes.Public | MethodAttributes.SpecialName, type.Module.TypeSystem.Void ) { IsSynchronized = !type.IsInterface, IsAddOn = true, MetadataToken = new MetadataToken(TokenType.Method, GlobalContainer.GetFreeRID(type.Module)), Parameters = { new ParameterDefinition("value", ParameterAttributes.None, eventType) } }; //Checks if the destination type is an interface if (type.IsInterface) { evt.AddMethod.Attributes |= MethodAttributes.NewSlot | MethodAttributes.CheckAccessOnOverride | MethodAttributes.Abstract | MethodAttributes.Virtual; } else { //Writes the instruction of the addon method var addBody = evt.AddMethod.Body; addBody.MaxStackSize = 8; addBody.GetType().GetField("code_size", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).SetValue(addBody, 1); var addIL = addBody.GetILProcessor(); addIL.Emit(OpCodes.Ldarg_0); addIL.Emit(OpCodes.Ldarg_0); addIL.Emit(OpCodes.Ldfld, backingField); addIL.Emit(OpCodes.Ldarg_1); //Delegate.Combine(Delegate, Delegate) addIL.Emit(OpCodes.Call, type.Module.Import(new TypeReference("System", "Delegate", type.Module, type.Module.TypeSystem.Corlib).Resolve().Methods.First(x => x.Name == "Combine" && x.IsStatic && x.Parameters.Count == 2 && x.Parameters.All(p => p.ParameterType.FullName == "System.Delegate")))); addIL.Emit(OpCodes.Castclass, eventType); addIL.Emit(OpCodes.Stfld, backingField); addIL.Emit(OpCodes.Ret); } //Creates the removeon method evt.RemoveMethod = new MethodDefinition( "remove_" + name, MethodAttributes.Public | MethodAttributes.SpecialName, type.Module.TypeSystem.Void ) { IsSynchronized = !type.IsInterface, IsRemoveOn = true, MetadataToken = new MetadataToken(TokenType.Method, GlobalContainer.GetFreeRID(type.Module)), Parameters = { new ParameterDefinition("value", ParameterAttributes.None, eventType) } }; //Checks if the destination type is an interface if (type.IsInterface) { evt.RemoveMethod.Attributes |= MethodAttributes.NewSlot | MethodAttributes.CheckAccessOnOverride | MethodAttributes.Abstract | MethodAttributes.Virtual; } else { //Writes the instruction of the removeon method var removeBody = evt.RemoveMethod.Body; removeBody.MaxStackSize = 8; removeBody.GetType().GetField("code_size", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).SetValue(removeBody, 1); var removeIL = removeBody.GetILProcessor(); removeIL.Emit(OpCodes.Ldarg_0); removeIL.Emit(OpCodes.Ldarg_0); removeIL.Emit(OpCodes.Ldfld, backingField); removeIL.Emit(OpCodes.Ldarg_1); //Delegate.Remove(Delegate, Delegate) removeIL.Emit(OpCodes.Call, type.Module.Import(new TypeReference("System", "Delegate", type.Module, type.Module.TypeSystem.Corlib).Resolve().Methods.First(x => x.Name == "Remove" && x.IsStatic && x.Parameters.Count == 2 && x.Parameters.All(p => p.ParameterType.FullName == "System.Delegate")))); removeIL.Emit(OpCodes.Castclass, eventType); removeIL.Emit(OpCodes.Stfld, backingField); removeIL.Emit(OpCodes.Ret); } //Adds the members to the type type.Methods.Add(evt.AddMethod); type.Methods.Add(evt.RemoveMethod); type.Events.Add(evt); evt.AddMethod.Overrides.Clear(); evt.RemoveMethod.Overrides.Clear(); //Creates the nodes if (node is TypeTreeNode) { if (!type.IsInterface) { node.Children.Add(new ILEditTreeNode(backingField, true)); } node.Children.Add(new ILEditTreeNode(evt, false)); Helpers.Tree.SortChildren((TypeTreeNode)node); } else if (node is ILEditTreeNode) { ((ILEditTreeNode)node).RefreshChildren(); } }
public void Inject(ICSharpCode.ILSpy.TreeNodes.ILSpyTreeNode node, string name, IMetadataTokenProvider member) { //Name and namespace var typeName = node is ModuleTreeNode ? (name.Substring(name.Contains(".") ? name.LastIndexOf('.') + 1 : 0)) : name; var typeNamespace = node is ModuleTreeNode ? (name.Substring(0, name.Contains(".") ? name.LastIndexOf('.') : 0)) : string.Empty; //Checks that the typename isn't empty if (string.IsNullOrEmpty(typeName)) { MessageBox.Show("Please, specify the name of the type", "Type name required", MessageBoxButton.OK, MessageBoxImage.Error); return; } //Creates a new class definition var c = new TypeDefinition( typeNamespace, typeName, TypeAttributes.Class | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.Sealed | TypeAttributes.Public ) { IsAnsiClass = true, }; //Module ModuleDefinition module = null; //Adds the type Helpers.Tree.AddTreeNode(node, c, m => { module = m; c.BaseType = m.Import(new TypeReference("System", "MulticastDelegate", m, m.TypeSystem.Corlib)); }, type => { module = type.Module; c.BaseType = type.Module.Import(new TypeReference("System", "MulticastDelegate", type.Module, type.Module.TypeSystem.Corlib)); } ); //Adds the .ctor method c.Methods.Add(new MethodDefinition( ".ctor", MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, module.TypeSystem.Void ) { IsPublic = true, IsSpecialName = true, IsRuntimeSpecialName = true, IsRuntime = true, IsManaged = true, Parameters = { new ParameterDefinition("object", ParameterAttributes.None, module.TypeSystem.Object), new ParameterDefinition("method", ParameterAttributes.None, module.TypeSystem.IntPtr) } }); //Adds the Invoke() method c.Methods.Add(new MethodDefinition( "Invoke", MethodAttributes.Public | MethodAttributes.NewSlot | MethodAttributes.Virtual, module.TypeSystem.Void ) { IsPublic = true, IsNewSlot = true, IsVirtual = true, IsRuntime = true, IsManaged = true }); //Adds the BeginInvoke() method c.Methods.Add(new MethodDefinition( "BeginInvoke", MethodAttributes.Public | MethodAttributes.NewSlot | MethodAttributes.Virtual, new TypeReference("System", "IAsyncResult", module, module.TypeSystem.Corlib) ) { IsPublic = true, IsNewSlot = true, IsVirtual = true, IsRuntime = true, IsManaged = true, Parameters = { new ParameterDefinition("callback", ParameterAttributes.None, new TypeReference("System", "AsyncCallback", module, module.TypeSystem.Corlib)), new ParameterDefinition("object", ParameterAttributes.None, module.TypeSystem.Object) } }); //Adds the EndInvoke() method c.Methods.Add(new MethodDefinition( "EndInvoke", MethodAttributes.Public | MethodAttributes.NewSlot | MethodAttributes.Virtual, module.TypeSystem.Void ) { IsPublic = true, IsNewSlot = true, IsVirtual = true, IsRuntime = true, IsManaged = true, Parameters = { new ParameterDefinition("result", ParameterAttributes.None, new TypeReference("System", "IAsyncResult", module, module.TypeSystem.Corlib)) } }); }
internal static void Execute(ILSpyTreeNode[] nodes) { if (!CanExecute(nodes)) return; var propNodes = nodes.Select(a => (PropertyTreeNode)a).ToArray(); UndoCommandManager.Instance.Add(new DeletePropertyDefCommand(propNodes)); }
static void Initialize(ILSpyTreeNode[] nodes, MenuItem menuItem) { if (nodes.Length == 1) menuItem.Header = string.Format("Delete {0}", UIUtils.EscapeMenuItemHeader(nodes[0].ToString())); else menuItem.Header = string.Format("Delete {0} properties", nodes.Length); }
public void Inject(ICSharpCode.ILSpy.TreeNodes.ILSpyTreeNode node, string name, IMetadataTokenProvider member) { //Type node var type = (TypeDefinition)((IMemberTreeNode)node).Member; //Property type var propertyType = type.Module.Import((TypeReference)member, type); //Creates the property definition var prop = new PropertyDefinition( name, PropertyAttributes.None, propertyType ) { MetadataToken = new MetadataToken(TokenType.Property, ILEdit.GlobalContainer.GetFreeRID(type.Module)) }; //Creates the backing field if we aren't injecting in an interface FieldReference backingField = null; if (!type.IsInterface) { backingField = new FieldDefinition(string.Format("<{0}>k__BackingField", name), FieldAttributes.Private, propertyType) { MetadataToken = new MetadataToken(TokenType.Field, ILEdit.GlobalContainer.GetFreeRID(type.Module)) }; type.Fields.Add((FieldDefinition)backingField); } //Checks if the type is generic if (type.HasGenericParameters) { var giType = new GenericInstanceType(type); foreach (var x in type.GenericParameters) { giType.GenericArguments.Add(x); } backingField = new FieldReference(backingField.Name, propertyType, giType); } //Creates the get method prop.GetMethod = new MethodDefinition( "get_" + name, MethodAttributes.Public | MethodAttributes.SpecialName, propertyType ) { IsGetter = true, MetadataToken = new MetadataToken(TokenType.Method, ILEdit.GlobalContainer.GetFreeRID(type.Module)) }; //Checks if the destination type is an interface if (type.IsInterface) { prop.GetMethod.Attributes |= MethodAttributes.NewSlot | MethodAttributes.CheckAccessOnOverride | MethodAttributes.Abstract | MethodAttributes.Virtual; } else { //Writes the instructions in the get method var getBody = prop.GetMethod.Body; getBody.MaxStackSize = 1; getBody.GetType().GetField("code_size", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).SetValue(getBody, 1); //ILSpy doesn't decompile the method otherwise! var getProcessor = getBody.GetILProcessor(); getProcessor.Emit(OpCodes.Ldarg_0); getProcessor.Emit(OpCodes.Ldfld, backingField); getProcessor.Emit(OpCodes.Ret); } //Creates the set method prop.SetMethod = new MethodDefinition( "set_" + name, MethodAttributes.Public | MethodAttributes.SpecialName, type.Module.TypeSystem.Void ) { IsSetter = true, MetadataToken = new MetadataToken(TokenType.Method, ILEdit.GlobalContainer.GetFreeRID(type.Module)), Parameters = { new ParameterDefinition("value", ParameterAttributes.None, propertyType) } }; //Checks if the destination type is an interface if (type.IsInterface) { prop.SetMethod.Attributes |= MethodAttributes.NewSlot | MethodAttributes.CheckAccessOnOverride | MethodAttributes.Abstract | MethodAttributes.Virtual; } else { //Writes the instructions in the set method var setBody = prop.SetMethod.Body; setBody.MaxStackSize = 8; setBody.GetType().GetField("code_size", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).SetValue(setBody, 1); var setProcessor = setBody.GetILProcessor(); setProcessor.Emit(OpCodes.Ldarg_0); setProcessor.Emit(OpCodes.Ldarg_1); setProcessor.Emit(OpCodes.Stfld, backingField); setProcessor.Emit(OpCodes.Ret); } //Adds the property to the type type.Properties.Add(prop); type.Methods.Add(prop.GetMethod); type.Methods.Add(prop.SetMethod); prop.GetMethod.Overrides.Clear(); //Overrides automatically added?! prop.SetMethod.Overrides.Clear(); //Creates the nodes if (node is TypeTreeNode) { if (!type.IsInterface) { node.Children.Add(new ILEditTreeNode(backingField, true)); } node.Children.Add(new ILEditTreeNode(prop, false)); Helpers.Tree.SortChildren((TypeTreeNode)node); } else if (node is ILEditTreeNode) { ((ILEditTreeNode)node).RefreshChildren(); } }
protected override void ExecuteInternal(ILSpyTreeNode[] nodes) { DeletePropertyDefCommand.Execute(nodes); }
protected override bool CanExecuteInternal(ILSpyTreeNode[] nodes) { return GetAssemblyNodes(nodes).Count > 0; }
PropertyDefSettingsCommand(PropertyTreeNode propNode, PropertyDefOptions options) { this.propNode = propNode; this.newOptions = options; this.origOptions = new PropertyDefOptions(propNode.PropertyDefinition); this.origParentNode = (ILSpyTreeNode)propNode.Parent; this.origParentChildIndex = this.origParentNode.Children.IndexOf(propNode); Debug.Assert(this.origParentChildIndex >= 0); if (this.origParentChildIndex < 0) throw new InvalidOperationException(); this.nameChanged = origOptions.Name != newOptions.Name; }
protected override void ExecuteInternal(ILSpyTreeNode[] nodes) { var asmNodes = GetAssemblyNodes(nodes); Saver.SaveAssemblies(asmNodes); }
static void Execute(ILSpyTreeNode[] nodes) { if (!CanExecute(nodes)) return; var propNode = (PropertyTreeNode)nodes[0]; var module = ILSpyTreeNode.GetModule(nodes[0]); Debug.Assert(module != null); if (module == null) throw new InvalidOperationException(); var data = new PropertyOptionsVM(new PropertyDefOptions(propNode.PropertyDefinition), module, MainWindow.Instance.CurrentLanguage, propNode.PropertyDefinition.DeclaringType); var win = new PropertyOptionsDlg(); win.DataContext = data; win.Owner = MainWindow.Instance; if (win.ShowDialog() != true) return; UndoCommandManager.Instance.Add(new PropertyDefSettingsCommand(propNode, data.CreatePropertyDefOptions())); }
HashSet<LoadedAssembly> GetAssemblyNodes(ILSpyTreeNode[] nodes) { var hash = new HashSet<LoadedAssembly>(); foreach (var node in nodes) { var asmNode = ILSpyTreeNode.GetNode<AssemblyTreeNode>(node); if (asmNode != null && asmNode.LoadedAssembly.ModuleDefinition != null) hash.Add(asmNode.LoadedAssembly); } return hash; }
protected override void ExecuteInternal(ILSpyTreeNode[] nodes) { PropertyDefSettingsCommand.Execute(nodes); }
static bool CanExecute(ILSpyTreeNode[] nodes) { return nodes.Length == 1 && (nodes[0] is TypeTreeNode || nodes[0].Parent is TypeTreeNode); }