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);
}
