public InterfaceEventImplementedByNode(EventDef analyzedEvent) { if (analyzedEvent == null) throw new ArgumentNullException("analyzedEvent"); this.analyzedEvent = analyzedEvent; this.analyzedMethod = this.analyzedEvent.AddMethod ?? this.analyzedEvent.RemoveMethod; }
public AnalyzedEventTreeNode(EventDef analyzedEvent, bool hidesParent = false) { if (analyzedEvent == null) throw new ArgumentNullException("analyzedEvent"); this.analyzedEvent = analyzedEvent; this.hidesParent = hidesParent; this.LazyLoading = true; }
public AnalyzedEventOverridesTreeNode(EventDef analyzedEvent) { if (analyzedEvent == null) throw new ArgumentNullException("analyzedEvent"); this.analyzedEvent = analyzedEvent; }
public AnalyzedEventTreeNode(EventDef analyzedEvent, string prefix = "") { if (analyzedEvent == null) throw new ArgumentNullException("analyzedEvent"); this.analyzedEvent = analyzedEvent; this.prefix = prefix; this.LazyLoading = true; }
public DeletedEventUpdater(ModuleDocumentNode modNode, EventDef originalEvent) { ownerNode = modNode.Context.DocumentTreeView.FindNode(originalEvent); if (ownerNode == null) throw new InvalidOperationException(); parentNode = ownerNode.TreeNode.Parent.Data; ownerType = originalEvent.DeclaringType; @event = originalEvent; }
private static string ResolveRawName(dnlib.DotNet.EventDef source) { var rawName = source.FullName.AsSpan(source.FullName.IndexOf(' ', StringComparison.InvariantCultureIgnoreCase) + 1); return(rawName.ToString() .Replace("::", ".", StringComparison.InvariantCultureIgnoreCase) .Replace("/", ".", StringComparison.InvariantCultureIgnoreCase)); }
public EditedEventUpdater(ModuleDocumentNode modNode, EventDef originalEvent, EventDefOptions eventDefOptions) { ownerNode = modNode.Context.DocumentTreeView.FindNode(originalEvent); if (ownerNode == null) throw new InvalidOperationException(); @event = originalEvent; originalEventDefOptions = new EventDefOptions(originalEvent); newEventDefOptions = eventDefOptions; }
public static ITextOutput Write(ITextOutput output, EventDef ev, Language language) { output.Write(UIUtils.CleanUpIdentifier(ev.Name), TextTokenHelper.GetTextTokenType(ev)); output.WriteSpace(); output.Write(':', TextTokenType.Operator); output.WriteSpace(); language.TypeToString(output, ev.EventType, false, ev); ev.MDToken.WriteSuffixString(output); return output; }
public EventDefOptions(EventDef evt) { Attributes = evt.Attributes; Name = evt.Name; EventType = evt.EventType; AddMethod = evt.AddMethod; InvokeMethod = evt.InvokeMethod; RemoveMethod = evt.RemoveMethod; OtherMethods.AddRange(evt.OtherMethods); CustomAttributes.AddRange(evt.CustomAttributes); }
public AnalyzedEventFiredByTreeNode(EventDef analyzedEvent) { if (analyzedEvent == null) throw new ArgumentNullException("analyzedEvent"); this.analyzedEvent = analyzedEvent; this.eventBackingField = GetBackingField(analyzedEvent); this.eventFiringMethod = analyzedEvent.EventType.ResolveTypeDef().Methods.First(md => md.Name == "Invoke"); }
public EventDefOptions(EventDef evt) { this.Attributes = evt.Attributes; this.Name = evt.Name; this.EventType = evt.EventType; this.AddMethod = evt.AddMethod; this.InvokeMethod = evt.InvokeMethod; this.RemoveMethod = evt.RemoveMethod; this.OtherMethods.AddRange(evt.OtherMethods); this.CustomAttributes.AddRange(evt.CustomAttributes); }
/// <summary> /// Default constructor /// </summary> /// <param name="resolver">Type resolver instance</param> /// <param name="source">Member source</param> internal EventDef(Resolver resolver, dnlib.DotNet.EventDef source) : base(resolver, source) { Name = source.Name.String; Type = ResolveType(source); IsStatic = source.AddMethod.IsStatic; Inheritance = ResolveInheritance(source.RemoveMethod); Accessor = ResolveAccessor(source.AddMethod); RawName = ResolveRawName(source); }
public EventFiredByNode(EventDef analyzedEvent) { if (analyzedEvent == null) throw new ArgumentNullException(nameof(analyzedEvent)); this.analyzedEvent = analyzedEvent; eventBackingField = GetBackingField(analyzedEvent); var eventType = analyzedEvent.EventType.ResolveTypeDef(); if (eventType != null) eventFiringMethod = eventType.Methods.First(md => md.Name == "Invoke"); }
public EventDef CopyTo(EventDef evt) { evt.Attributes = this.Attributes; evt.Name = this.Name ?? UTF8String.Empty; evt.EventType = this.EventType; evt.AddMethod = this.AddMethod; evt.InvokeMethod = this.InvokeMethod; evt.RemoveMethod = this.RemoveMethod; evt.OtherMethods.Clear(); evt.OtherMethods.AddRange(this.OtherMethods); evt.CustomAttributes.Clear(); evt.CustomAttributes.AddRange(CustomAttributes); return evt; }
public EventTreeNode(EventDef ev) { if (ev == null) throw new ArgumentNullException("ev"); this.ev = ev; if (ev.AddMethod != null) this.Children.Add(new MethodTreeNode(ev.AddMethod)); if (ev.RemoveMethod != null) this.Children.Add(new MethodTreeNode(ev.RemoveMethod)); if (ev.InvokeMethod != null) this.Children.Add(new MethodTreeNode(ev.InvokeMethod)); if (ev.HasOtherMethods) { foreach (var m in ev.OtherMethods) this.Children.Add(new MethodTreeNode(m)); } }
static MemberIcon GetMemberIcon(EventDef eventDef) { MethodDef method = eventDef.AddMethod ?? eventDef.RemoveMethod; if (method == null) return MemberIcon.Event; var access = MethodTreeNode.GetMemberAccess(method); if (method.IsStatic) { switch (access) { case MemberAccess.Public: return MemberIcon.StaticEvent; case MemberAccess.Private: return MemberIcon.StaticEventPrivate; case MemberAccess.Protected: return MemberIcon.StaticEventProtected; case MemberAccess.Internal: return MemberIcon.StaticEventInternal; case MemberAccess.CompilerControlled: return MemberIcon.StaticEventCompilerControlled; case MemberAccess.ProtectedInternal: return MemberIcon.StaticEventProtectedInternal; default: Debug.Fail("Invalid MemberAccess"); goto case MemberAccess.Public; } } if (method.IsVirtual) { switch (access) { case MemberAccess.Public: return MemberIcon.VirtualEvent; case MemberAccess.Private: return MemberIcon.VirtualEventPrivate; case MemberAccess.Protected: return MemberIcon.VirtualEventProtected; case MemberAccess.Internal: return MemberIcon.VirtualEventInternal; case MemberAccess.CompilerControlled: return MemberIcon.VirtualEventCompilerControlled; case MemberAccess.ProtectedInternal: return MemberIcon.VirtualEventProtectedInternal; default: Debug.Fail("Invalid MemberAccess"); goto case MemberAccess.Public; } } switch (access) { case MemberAccess.Public: return MemberIcon.Event; case MemberAccess.Private: return MemberIcon.EventPrivate; case MemberAccess.Protected: return MemberIcon.EventProtected; case MemberAccess.Internal: return MemberIcon.EventInternal; case MemberAccess.CompilerControlled: return MemberIcon.EventCompilerControlled; case MemberAccess.ProtectedInternal: return MemberIcon.EventProtectedInternal; default: Debug.Fail("Invalid MemberAccess"); goto case MemberAccess.Public; } }
public override void DecompileEvent(EventDef ev, ITextOutput output, DecompilationOptions options) { StartKeywordBlock(output, ".event", ev); if (ev.AddMethod != null) { StartKeywordBlock(output, ".add", ev.AddMethod); EndKeywordBlock(output); } if (ev.InvokeMethod != null) { StartKeywordBlock(output, ".invoke", ev.InvokeMethod); EndKeywordBlock(output); } if (ev.RemoveMethod != null) { StartKeywordBlock(output, ".remove", ev.RemoveMethod); EndKeywordBlock(output); } EndKeywordBlock(output); }
public static IEnumerable<EventDef> FindBaseEvents(EventDef eventDef) { if (eventDef == null) yield break; var eventType = eventDef.EventType.ToTypeSig(); foreach (var baseType in BaseTypes(eventDef.DeclaringType)) { var baseTypeDef = baseType.Resolve(); if (baseTypeDef == null) continue; foreach (var baseEvent in baseTypeDef.Events) { if (MatchEvent(baseEvent, Resolve(baseEvent.EventType.ToTypeSig(), baseType), eventDef, eventType) && IsVisibleFromDerived(baseEvent, eventDef.DeclaringType)) { yield return baseEvent; var anyEventAccessor = baseEvent.AddMethod ?? baseEvent.RemoveMethod; if (anyEventAccessor != null && anyEventAccessor.IsNewSlot == anyEventAccessor.IsVirtual) yield break; } } } }
public override void DecompileEvent(EventDef ev, ITextOutput output, DecompilationOptions options) { ReflectionDisassembler rd = CreateReflectionDisassembler(output, options, ev); rd.DisassembleEvent(ev); if (ev.AddMethod != null) { output.WriteLine(); rd.DisassembleMethod(ev.AddMethod); } if (ev.RemoveMethod != null) { output.WriteLine(); rd.DisassembleMethod(ev.RemoveMethod); } foreach (var m in ev.OtherMethods) { output.WriteLine(); rd.DisassembleMethod(m); } }
void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, EventDef evt) { if (evt.DeclaringType.IsVisibleOutside() && !IsVisibleOutside(context, parameters, evt)) service.SetCanRename(evt, false); else if (evt.IsRuntimeSpecialName) service.SetCanRename(evt, false); }
public static bool CanShow(EventDef ev) { return ev.DeclaringType.IsInterface; }
public override TreeViewNodeFilterResult GetFilterResult(EventDef evt) { var visibleFlags = VisibleMembersFlags.EventDef | VisibleMembersFlags.MethodDef | VisibleMembersFlags.MethodBody | VisibleMembersFlags.ParamDefs | VisibleMembersFlags.ParamDef | VisibleMembersFlags.Locals | VisibleMembersFlags.Local; bool isMatch = (flags & VisibleMembersFlags.EventDef) != 0; if ((flags & visibleFlags) == 0) return new TreeViewNodeFilterResult(FilterResult.Hidden, isMatch); if (isMatch) return new TreeViewNodeFilterResult(FilterResult.Match, isMatch); // Make sure it's not hidden return new TreeViewNodeFilterResult(FilterResult.Recurse, isMatch); }
void Search(IDnSpyFile ownerModule, TypeDef type, EventDef evt) { var res = options.Filter.GetResult(evt); if (res.FilterType == FilterType.Hide) return; CheckCustomAttributes(ownerModule, evt, type); if (res.IsMatch && IsMatch(evt.Name, evt)) { options.OnMatch(new SearchResult { Context = options.Context, Object = evt, NameObject = evt, ObjectImageReference = options.DotNetImageManager.GetImageReference(evt), LocationObject = type, LocationImageReference = options.DotNetImageManager.GetImageReference(type), DnSpyFile = ownerModule, }); } }
public TreeNode NewEvent(EventDef @event) { TreeNode node = NewNode(String.Format("{0}: {1}", @event.Name, "EventHandler")); node.Tag = @event; node.ImageIndex = node.SelectedImageIndex = 15; if (@event.AddMethod != null) { node.Nodes.Add(NewMethod(@event.AddMethod)); } if (@event.RemoveMethod != null) { node.Nodes.Add(NewMethod(@event.RemoveMethod)); } if (@event.InvokeMethod != null) { node.Nodes.Add(NewMethod(@event.InvokeMethod)); } foreach (MethodDef method in @event.OtherMethods) { node.Nodes.Add(NewMethod(method)); } return node; }
public static bool CanShow(EventDef ev) { return GetBackingField(ev) != null; }
/// <summary> /// Looks up the event node corresponding to the event definition. /// Returns null if no matching node is found. /// </summary> public EventTreeNode FindEventNode(EventDef def) { if (def == null) return null; TypeTreeNode typeNode = FindTypeNode(def.DeclaringType); if (typeNode == null) return null; typeNode.EnsureChildrenFiltered(); return typeNode.Children.OfType<EventTreeNode>().FirstOrDefault(m => m.EventDefinition == def); }
public virtual DocumentTreeNodeFilterResult GetResult(EventDef evt) => new DocumentTreeNodeFilterResult();
// HACK: we should probably examine add/remove methods to determine this private static FieldDef GetBackingField(EventDef ev) { var fieldName = ev.Name; var vbStyleFieldName = fieldName + "Event"; var fieldType = ev.EventType; if (fieldType == null) return null; foreach (var fd in ev.DeclaringType.Fields) { if (fd.Name == fieldName || fd.Name == vbStyleFieldName) if (new SigComparer().Equals(fd.FieldType, fieldType)) return fd; } return null; }
public virtual void Decompile(EventDef ev, IDecompilerOutput output, DecompilationContext ctx) => this.WriteCommentLine(output, TypeToString(ev.DeclaringType, true) + "." + ev.Name);
static IEnumerable<MethodDef> GetMethods(EventDef evt) { if (evt.AddMethod != null) yield return evt.AddMethod; if (evt.InvokeMethod != null) yield return evt.InvokeMethod; if (evt.RemoveMethod != null) yield return evt.RemoveMethod; foreach (var m in evt.OtherMethods) yield return m; }
public ModelInfo(EventDef evt) { this.OwnerType = evt.DeclaringType; this.EventIndex = this.OwnerType.Events.IndexOf(evt); Debug.Assert(this.EventIndex >= 0); this.Methods = new HashSet<MethodDef>(GetMethods(evt)).ToArray(); this.MethodIndexes = new int[this.Methods.Length]; }
private IResType ResolveType(dnlib.DotNet.EventDef source) => Resolver.Resolve(source.EventType.ToTypeSig());
public virtual TreeViewNodeFilterResult GetFilterResult(EventDef evt) { return new TreeViewNodeFilterResult(FilterResult.Hidden, false); }