public Debugger(Process process) { if (process == null) throw new ArgumentNullException("process"); this.process = process; this.thread = this.process.Threads[0]; this.hThread = OpenThread(0x1F03FF, false, thread.Id); if (this.hThread == IntPtr.Zero) throw new Win32Exception(); }
//constructors /// <summary> /// Initialze the StackTrace Class and create all the FrameInfo objects /// </summary> /// <param name="proc">The thread to get the stack trace of</param> internal ThreadInfo(CorThread thread, ProcessInfo procInfo) { if (thread == null) { throw new ArgumentNullException("thread"); } if (procInfo == null) { throw new ArgumentNullException("procInfo"); } this.thread = thread; metaImportHash = new Dictionary<string, CorMetadataImport>(); frameStack = new List<FrameInfo>(); threadId = thread.Id; processInfo = procInfo; //get the general thread information object generalThreadInfo = procInfo.GeneralThreads[threadId]; }
// // Summary: // Determines whether the specified process thread exists in the collection. // // Parameters: // thread: // A System.Diagnostics.ProcessThread instance that indicates the thread to // find in this collection. // // Returns: // true if the thread exists in the collection; otherwise, false. public bool Contains(ProcessThread thread) { return default(bool); }
public static void addThreadToTreeView(TreeView treeView, ProcessThread thread) { var nodeText = thread.Id.str(); O2Forms.newTreeNode(treeView.Nodes, nodeText, 0, thread, true /*addDummyNode */); }
public bool Contains(ProcessThread thread) { return(InnerList.Contains(thread)); }
// Get the index of a specific element in this collection. public int IndexOf(ProcessThread value) { return(InnerList.IndexOf(value)); }
public TokenSecurity(ProcessThread thread, AccessControlSections sectionsRequested) : this(thread.Id, sectionsRequested, false) { }
/// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public ProcessThreadCollection(ProcessThread[] processThreads) { InnerList.AddRange(processThreads); }
private static ProcessThread[] GetThreads(Process process) { var threads = new ProcessThread[process.Threads.Count]; for (var i = 0; i < process.Threads.Count; i++) { threads[i] = process.Threads[i]; } return threads; }
public void Insert(int index, ProcessThread thread) { throw new NotImplementedException(); }
// // Summary: // Determines whether the specified process thread exists in the collection. // // Parameters: // thread: // A System.Diagnostics.ProcessThread instance that indicates the thread to // find in this collection. // // Returns: // true if the thread exists in the collection; otherwise, false. public bool Contains(ProcessThread thread) { return(default(bool)); }
// Summary: // Appends a process thread to the collection. // // Parameters: // thread: // The thread to add to the collection. // // Returns: // The zero-based index of the thread in the collection. public int Add(ProcessThread thread) { return(default(int)); }
public void Remove(ProcessThread thread) { }
// // Summary: // Provides the location of a specified thread within the collection. // // Parameters: // thread: // The System.Diagnostics.ProcessThread whose index is retrieved. // // Returns: // The zero-based index that defines the location of the thread within the System.Diagnostics.ProcessThreadCollection. public int IndexOf(ProcessThread thread) { return(default(int)); }
// // Summary: // Provides the location of a specified thread within the collection. // // Parameters: // thread: // The System.Diagnostics.ProcessThread whose index is retrieved. // // Returns: // The zero-based index that defines the location of the thread within the System.Diagnostics.ProcessThreadCollection. public int IndexOf(ProcessThread thread) { return default(int); }
public ThreadSecurity(ProcessThread thread, AccessControlSections sectionsRequired) : this(thread.Id, sectionsRequired) { }
public int IndexOf(ProcessThread thread) { throw new NotImplementedException(); }
/// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void Remove(ProcessThread thread) { InnerList.Remove(thread); }
public bool Contains(ProcessThread thread) { throw new NotImplementedException(); }
/// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void Insert(int index, ProcessThread thread) { InnerList.Insert(index, thread); }
public void Remove(ProcessThread thread) { throw new NotImplementedException(); }
// Add an element to this collection. public int Add(ProcessThread value) { return(InnerList.Add(value)); }
private static IntPtr ThreadPointer(ProcessThread processThread) { return OpenThread(ThreadAccess.SUSPEND_RESUME, false, (uint)processThread.Id); }
public void Remove(ProcessThread thread) { InnerList.Remove(thread); }
public int BinarySearch(ProcessThread item) { throw new NotSupportedException(); }
public void Insert(int index, ProcessThread thread) { InnerList.Insert(index, thread); }
public int BinarySearch(ProcessThread item, System.Collections.Generic.IComparer <ProcessThread> comparer) { throw new NotSupportedException(); }
// Get the index of a specific element in this collection. public int IndexOf(ProcessThread value) { return InnerList.IndexOf(value); }
public int LastIndexOf(ProcessThread item, int index, int count) { throw new NotSupportedException(); }
// // Summary: // Copies an array of System.Diagnostics.ProcessThread instances to the collection, // at the specified index. // // Parameters: // array: // An array of System.Diagnostics.ProcessThread instances to add to the collection. // // index: // The location at which to add the new instances. public void CopyTo(ProcessThread[] array, int index) { }
private static string GetThreadState(ProcessThread pt) { if (pt == null) return ""; StringBuilder sb = new StringBuilder(); sb.AppendLine(" Thread ID='" + pt.Id + "' Start=" + pt.StartTime.ToString("s")); sb.Append(" System.Diagnostics.ThreadState = " + pt.ThreadState.ToString()); if (pt.ThreadState == System.Diagnostics.ThreadState.Wait) sb.Append(" (ThreadWaitReason=" + pt.WaitReason.ToString() + ")"); return sb.ToString(); }
/// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public int Add(ProcessThread thread) { return(((IList)InnerList).Add(thread)); }
/// <summary> /// Retrieves the process that created the window, when available. /// </summary> /// <returns>The process when available, null otherwise.</returns> public Process GetProcess() { if ( _process == null ) { uint processId; uint threadId = User32.GetWindowThreadProcessId( Handle, out processId ); if ( threadId == 0 ) { MarshalHelper.ThrowLastWin32ErrorException(); } try { _process = processId == 0 ? null : Process.GetProcessById( (int)processId ); } catch ( ArgumentException ) { // The process specified by processId parameter is not running. // GetWindowThreadProcessId at one point returned a processId of a process which was not running. Possibly a remnant window of a crashed process? _process = null; } if ( _process != null ) { try { _processThread = ( from ProcessThread t in _process.Threads where t.Id == threadId select t ).First(); } catch ( InvalidOperationException ) { // Process has since been shut down. _process = null; } } } return _process; }
/// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public int Add(ProcessThread thread) { return InnerList.Add(thread); }
public int Add(System.Diagnostics.ProcessThread thread) { throw null; }
/// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public bool Contains(ProcessThread thread) { return InnerList.Contains(thread); }
public bool Contains(System.Diagnostics.ProcessThread thread) { throw null; }
/// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void CopyTo(ProcessThread[] array, int index) { InnerList.CopyTo(array, index); }
public int IndexOf(System.Diagnostics.ProcessThread thread) { throw null; }
/// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public int Add(ProcessThread thread) { return ((IList)InnerList).Add(thread); }
public void Insert(int index, System.Diagnostics.ProcessThread thread) { }
/// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public int IndexOf(ProcessThread thread) { return InnerList.IndexOf(thread); }
public void Remove(System.Diagnostics.ProcessThread thread) { }
internal ProcessThreadCollection(ProcessThread module) { InnerList.Add(module); }
/// <param name="thread"></param>Thread, dessen CPU-Auslastung das Programm herrausfinden soll </param> /// <param name="aktualisierungsintervall">gibt die Pause zwischen zwei Messungen in ms an</param> public ThreadListener(ProcessThread thread, int aktualisierungsintervall) { _aktualisierungsintervall = aktualisierungsintervall; _thread = thread; _id = thread.Id; }
// Determine if an item exists in this collection. public bool Contains(ProcessThread value) { return(InnerList.Contains(value)); }
/// <param name="thread"></param>Thread, dessen CPU-Auslastung das Programm herrausfinden soll </param> public ThreadListener(ProcessThread thread) { _aktualisierungsintervall = 4000; _thread = thread; _id = thread.Id; }
private void _thread_start() { _processThread = GetCurrentProcessThread(); AllGThreads.Add(this); if (OnNewGThread != null) OnNewGThread(this); try { _threadStart(); } catch (Exception ex) { Logging.Log.Exception("Unhandled GThread Excaption", ex, this); if (OnError != null) OnError(this, ex); } finally { if(AllGThreads.Contains(this)) AllGThreads.Remove(this); if (OnEndGThread != null) OnEndGThread(this); } }
public ThreadListener() { _aktualisierungsintervall = 4000; _thread = Process.GetCurrentProcess().Threads[0]; _id = _thread.Id; }
public int Add(ProcessThread thread) { return(InnerList.Add(thread)); }
// // Summary: // Inserts a process thread at the specified location in the collection. // // Parameters: // index: // The zero-based index indicating the location at which to insert the thread. // // thread: // The thread to insert into the collection. public void Insert(int index, ProcessThread thread) { // // Summary: // Deletes a process thread from the collection. // // Parameters: // thread: // The thread to remove from the collection. }
public int IndexOf(ProcessThread thread) { return(InnerList.IndexOf(thread)); }
public void showThreadDetailsOnTreeNode(TreeNode treeNode, ProcessThread processThread) { treeNode.Nodes.Clear(); foreach(var property in PublicDI.reflection.getProperties(processThread)) { var propertyValue = PublicDI.reflection.getProperty(property,processThread); var nodeText = string.Format("{0} = {1}", property.Name, propertyValue ?? "[null]"); O2Forms.newTreeNode(treeNode.Nodes, nodeText); } }
// Summary: // Appends a process thread to the collection. // // Parameters: // thread: // The thread to add to the collection. // // Returns: // The zero-based index of the thread in the collection. public int Add(ProcessThread thread) { return default(int); }
internal override void Update(TreeNodeData tnd, bool allowUnsafeChanges, MainForm mf) { currentThread = ((ThreadData)tnd).Thread; UpdateControls(); }
public void Insert(int index, ProcessThread thread) { }