public override CallStack FindStack(Method method) { CallStack getStack = null; CallStack setStack = null; if (this.Get != null) { getStack = this.Get.FindStack(method); } if (this.Set != null) { setStack = this.Set.FindStack(method); } else { return getStack; } if ((getStack == null) || (setStack.Count < getStack.Count)) { return setStack; } else { return getStack; } }
public MethodItem(Method method, ThrownException exception) { this.Method = method; this.Exception = exception; }
public MethodEventArgs(Method method, Method callingMethod, ThrownException exception) { this.Method = method; this.CallingMethod = callingMethod; this.Exception = exception; }
/// <summary>Updates the list.</summary> protected void UpdateList() { Job worker = Job.ExceptionTree.NewJob(this, (cancelToken) => { try { this.InvokeIfRequired(() => { try { this.SetWaiting(true); this.BeginUpdate(); this.Items.Clear(); } finally { this.EndUpdate(); } }); List<ListViewItem> items = new List<ListViewItem>(); if (this.MethodContainer is Class) { HashSet<string> got = new HashSet<string>(); foreach (Method m in this.MethodContainer.CalledMethods) { foreach (ThrownException ex in m.UnhandledExceptions) { if (this.Exceptions.Contains(ex)) { string id = ex.Method.GetId() + ex.Exception.FullName; if (!got.Contains(id)) { got.Add(id); //ListViewItem item = MakeItem(ex, ex.Method).Item; ListViewItem item = MakeItem(ex, m).Item; items.Add(item); } } } } } else if (this.GroupByType) { // group the exceptions by type ThrownExceptionDictionary dict = new ThrownExceptionDictionary(this.Exceptions); foreach (IEnumerable<ThrownException> list in dict.GetLists()) { Type type = list.First().Exception; ListViewGroup lvg = this.Groups.Add(type.FullName, type.Name); list.ToList().ForEach(item => items.Add(MakeItem(item, item.Method, lvg).Item)); } } else { IEnumerable<Method> methods; if (this.MethodContainer is Method) { } else { methods = new Method[] { this.MethodContainer as Method }.Concat(this.MethodContainer.CalledMethods); } foreach (ThrownException ex in this.Exceptions) { Method m = null; if (ex.Method == this.MethodContainer) { m = this.MethodContainer as Method; } else { m = this.MethodContainer.CalledMethods.FirstOrDefault(md => md.UnhandledExceptions.Contains(ex)); if (m == null) { m = this.MethodContainer as Method; } } ListViewItem item = MakeItem(ex, m).Item; items.Add(item); } } if (cancelToken.IsCancellationRequested) { return; } this.InvokeIfRequired(() => { try { this.BeginUpdate(); this.Items.AddRange(items.ToArray()); } finally { this.EndUpdate(); } }); } finally { this.SetWaiting(false); } }); worker.Execute(); }
/// <summary> /// Makes a new item. /// </summary> /// <param name="exception">The exception.</param> /// <param name="method">The method.</param> /// <param name="group">The group.</param> /// <returns></returns> protected ItemInfo MakeItem(ThrownException exception, Method method = null, ListViewGroup group = null) { bool isMethod = (method != null); bool isProperty = isMethod && method.MethodBase.IsProperty(); bool isThrow = !isMethod && (exception != null); if (!isMethod) { method = exception.Method; } ListViewItem item; PropertyInfo pi = null; if (isProperty) { bool getter = method.MethodBase.Name.StartsWith("get_"); pi = method.MethodBase.GetMethodProperty(); item = new ListViewItem(string.Format(CultureInfo.InvariantCulture, "{0} ({1})", pi.Name, getter ? "get" : "set")); } else { item = new ListViewItem(method.ToString()); } if (isProperty) { item.ImageKey = NodeInfo.ImageKeyFromObject(pi); } else if (isMethod) { // use the method for the icon item.ImageKey = NodeInfo.ImageKeyFromObject(method.MethodBase); } else { // use the exception for the icon item.ImageKey = NodeInfo.ImageKeyFromObject(exception.Exception); } ItemInfo info; MethodItem me = new MethodItem(method, exception); if (exception == null) { info = new ItemInfo(item, me, NodeType.Method); item.SubItems.Add(""); } else { info = new ItemInfo(item, me, NodeType.Method); info.Expandable = !isThrow; item.SubItems.Add(exception.Exception.Name); } item.Tag = info; item.SubItems.Add(method.MethodBase.DeclaringType.Name); item.SubItems.Add(method.MethodBase.DeclaringType.Module.Name); item.IndentCount = 1; if (group != null) { item.Group = group; } return info; }
void ShowMethodCall(Method caller, Method called) { Job.SourceView.NewJob(this.SourceViewer, (cancelToken) => { if ((caller == null) || (caller == called)) { this.SourceViewer.SetSource(called.MethodBase, cancelToken); } else { //this.SourceViewer.SetSource(caller.MethodBase, called.MethodBase, caller.Calls[called]); List<SourceViewer.HighlightItem> items = new List<SourceViewer.HighlightItem>(); foreach (int offset in caller.Calls[called]) { items.Add(new SourceViewer.HighlightItem(called.MethodBase) { Display = Decompiler.SourceViewer.HighlightDisplay.Highlight, Offset = offset, Tooltip = called.ToString() }); } this.SourceViewer.SetSource(caller.MethodBase, items, cancelToken); } }).Execute(); }
void ShowExceptionThrow(Method caller, ThrownException te) { if (caller == null) { caller = te.Method; } Job.SourceView.NewJob(this.SourceViewer, (cancelToken) => { if (Environment.TickCount == 123) { throw new TimeZoneNotFoundException(); } List<SourceViewer.HighlightItem> items = new List<SourceViewer.HighlightItem>(); foreach (ThrownException ex in caller.UnhandledExceptions) { if (ex.Exception == te.Exception) { SourceViewer.HighlightItem item = new SourceViewer.HighlightItem(te.Exception) { Display = Decompiler.SourceViewer.HighlightDisplay.Highlight, Offset = ex.Offset }; if (ex.IsXmlDoc) { item.HighlightType |= Decompiler.SourceViewer.HighlightType.DocumentedException; } items.Add(item); } } this.SourceViewer.SetSource(caller.MethodBase, items, cancelToken); }).Execute(); }
/// <summary> /// Finds the shortest callstack to the provided method. /// </summary> /// <param name="method">The method to search for.</param> /// <returns> /// The shortest call-stack from this method to the specified method. /// </returns> public override CallStack FindStack(Method method) { CallStack shortest = null; foreach (Method m in this.CalledMethods) { CallStack cs = m.FindStack(method); if ((cs != null) && (cs.Count > 0) && ((shortest == null) || (cs.Count < shortest.Count))) { shortest = cs; } } return shortest; }
/// <summary>Initializes a new instance of the <see cref="MethodCall"/> class.</summary> /// <param name="offset">The offset.</param> /// <param name="method">The method.</param> public MethodCall(int offset, Method method) { this.Method = method; this.Offset = offset; }
private Dictionary<string, NodeInfo> GetProperties(TreeNode node, Method method) { Dictionary<string, NodeInfo> properties = new Dictionary<string, NodeInfo>(); foreach (Method m in method.CalledMethods) { MethodBase mb = m.MethodBase; if (mb.Name.Contains("get_UserInt")) { } // see if it's a getter/setter if (mb.IsSpecialName && mb.IsHideBySig) { bool getter = mb.Name.StartsWith("get_"); if (getter || mb.Name.StartsWith("set_")) { NodeInfo ni = null; string name = mb.Name.Substring(4); PropertyInfo pi = null; bool alreadyFound = properties.ContainsKey(name); if (!alreadyFound) { try { pi = mb.DeclaringType.GetProperty(name, Binding); } catch (AmbiguousMatchException) { // be a bit more specific with the search Type returnType = typeof(void); if (mb is MethodInfo) { returnType = ((MethodInfo)mb).ReturnType; } IEnumerable<Type> paras = from p in mb.GetParameters() select p.ParameterType; if (!getter) { returnType = paras.Last(); paras = paras.Take(paras.Count() - 1); } pi = mb.DeclaringType.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static, null, returnType, paras.ToArray(), null); } if (pi == null) { continue; } ni = this.NewNode(new Property(pi), NodeType.Property).GetInfo(); ni.Node.Nodes.Clear(); properties.Add(name, ni); } else { ni = properties[name]; } if (m.UnhandledExceptions.Count > 0) { ni.Node.Nodes.Add(this.NewNode(getter ? "get" : "set", m, NodeType.Method)); if (!alreadyFound) { node.Nodes.Add(ni.Node); } } } } } return properties; }
private Dictionary<string, NodeInfo> GetEvents(TreeNode node, Method method) { Dictionary<string, NodeInfo> events = new Dictionary<string, NodeInfo>(); foreach (Method m in method.CalledMethods) { } return events; }
/// <summary>Finds the stack.</summary> /// <param name="method">The method.</param> /// <param name="stack">The stack.</param> /// <param name="shortest">The shortest.</param> /// <param name="visited">The visited.</param> /// <returns></returns> private int FindStack(Method method, CallStack stack, CallStack shortest, HashSet<Method> visited) { stack.Push(this); try { visited.Add(this); if ((shortest.Count > 0) && (stack.Count >= shortest.Count)) { // the shortest stack found is less than the current one - don't search any further return -1; } if (this == method) { // copy the current stack shortest.Clear(); foreach (Method m in stack) { shortest.Push(m); } return 0; } // go through the unhandled exceptions for each called method, and see if the method that the exception // matches the one being found. int best = -1; foreach (Method m in this.CalledMethods) { if (visited.Contains(m)) { continue; } // see if this method has an uncaught exception that was thrown in the target method var xx = m.UnhandledExceptions.FirstOrDefault(ex => ex.Method == method); var yy = m.UnhandledExceptions.Where(ex => ex.Method == method); bool found = (m == method) || m.UnhandledExceptions.FirstOrDefault(ex => ex.Method == method) != null; if (found) { int depth = m.FindStack(method, stack, shortest, visited); if (depth == 0) { // it's this one, no need to search the rest return depth + 1; } else if ((depth < best) || (best == -1)) { best = depth; } } } return best; } finally { stack.Pop(); } }
/// <summary>Finds the shortest callstack to the provided method.</summary> /// <param name="method">The method to search for.</param> /// <returns>The shortest call-stack from this method to the specified method.</returns> public override CallStack FindStack(Method method) { if (method == null) { return null; } HashSet<Method> visited = new HashSet<Method>(); CallStack shortest = new CallStack(); this.FindStack(method, new CallStack(), shortest, visited); visited.Clear(); return shortest; }
public CallStack GetCallstack(Method method) { return this.Method.FindStack(method); }
public void ReadProperty(ExceptionFinder finder, CancellationToken cancelToken) { Method[] methods = new Method[] { this.Get, this.Set }; foreach (Method m in methods) { if (m != null) { if (!m.Complete && (cancelToken != null)) { ExceptionFinder.Instance.ReadMethod(m, cancelToken); } this.CalledMethods.UnionWith(m.CalledMethods); this.UnhandledExceptions.UnionWith(m.UnhandledExceptions); this.DocumentedThrownExceptions.AddRange(m.DocumentedThrownExceptions); } } this._complete = ((this.Get == null) || this.Get.Complete) && ((this.Set == null) || this.Set.Complete); }
/// <summary>Finds the shortest callstack to the provided method.</summary> /// <param name="method">The method to search for.</param> /// <returns>The shortest call-stack from this method to the specified method.</returns> public abstract CallStack FindStack(Method method);