We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Diagnostics \ ProcessInfo

SSCLI
  1. //------------------------------------------------------------------------------
  2. // <copyright file="Process.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  16. namespace System.Diagnostics
  17. {
  18.     using System.Text;
  19.     using System.Threading;
  20.     using System.Runtime.InteropServices;
  21.     using System.ComponentModel;
  22.     using System.ComponentModel.Design;
  23.     using System.Runtime.CompilerServices;
  24.     using System.Runtime.ConstrainedExecution;
  25.     using System.Diagnostics;
  26.     using System;
  27.     using System.Collections;
  28.     using System.IO;
  29.     using Microsoft.Win32;
  30.     using Microsoft.Win32.SafeHandles;
  31.     using System.Collections.Specialized;
  32.     using System.Globalization;
  33.     using System.Security;
  34.     using System.Security.Permissions;
  35.     using System.Security.Principal;
  36.     using System.Runtime.Versioning;
  37.    
  38.     /// <devdoc>
  39.     /// <para>
  40.     /// Provides access to local and remote
  41.     /// processes. Enables you to start and stop system processes.
  42.     /// </para>
  43.     /// </devdoc>
  44.         // Disabling partial trust scenarios
  45.     [MonitoringDescription(SR.ProcessDesc), DefaultEvent("Exited"), DefaultProperty("StartInfo"), Designer("System.Diagnostics.Design.ProcessDesigner, " + AssemblyRef.SystemDesign), PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust"), PermissionSet(SecurityAction.InheritanceDemand, Name = "FullTrust"), HostProtection(SharedState = true, Synchronization = true, ExternalProcessMgmt = true, SelfAffectingProcessMgmt = true)]
  46.     public class Process : Component
  47.     {
  48.         //
  49.         // FIELDS
  50.         //
  51.        
  52.         bool haveProcessId;
  53.         int processId;
  54.         bool haveProcessHandle;
  55.         SafeProcessHandle m_processHandle;
  56.         bool isRemoteMachine;
  57.         string machineName;
  58.         ProcessInfo processInfo;
  59.        
  60.        
  61.         bool haveMainWindow;
  62.         IntPtr mainWindowHandle;
  63.         // no need to use SafeHandle for window
  64.         string mainWindowTitle;
  65.        
  66.         bool haveWorkingSetLimits;
  67.         IntPtr minWorkingSet;
  68.         IntPtr maxWorkingSet;
  69.        
  70.         bool haveProcessorAffinity;
  71.         IntPtr processorAffinity;
  72.        
  73.         bool havePriorityClass;
  74.         ProcessPriorityClass priorityClass;
  75.        
  76.         ProcessStartInfo startInfo;
  77.        
  78.         bool watchForExit;
  79.         bool watchingForExit;
  80.         EventHandler onExited;
  81.         bool exited;
  82.         int exitCode;
  83.         bool signaled;
  84.        
  85.         DateTime exitTime;
  86.         bool haveExitTime;
  87.        
  88.         bool responding;
  89.         bool haveResponding;
  90.        
  91.         bool priorityBoostEnabled;
  92.         bool havePriorityBoostEnabled;
  93.        
  94.         bool raisedOnExited;
  95.         RegisteredWaitHandle registeredWaitHandle;
  96.         WaitHandle waitHandle;
  97.         ISynchronizeInvoke synchronizingObject;
  98.         StreamReader standardOutput;
  99.         StreamWriter standardInput;
  100.         StreamReader standardError;
  101.         OperatingSystem operatingSystem;
  102.         bool disposed;
  103.        
  104.         // This enum defines the operation mode for redirected process stream.
  105.         // We don't support switching between synchronous mode and asynchronous mode.
  106.         private enum StreamReadMode
  107.         {
  108.             undefined,
  109.             syncMode,
  110.             asyncMode
  111.         }
  112.        
  113.         StreamReadMode outputStreamReadMode;
  114.         StreamReadMode errorStreamReadMode;
  115.        
  116.        
  117.         // Support for asynchrously reading streams
  118.         [Browsable(true), MonitoringDescription(SR.ProcessAssociated)]
  119.         //[System.Runtime.InteropServices.ComVisible(false)]
  120.         public event DataReceivedEventHandler OutputDataReceived;
  121.         [Browsable(true), MonitoringDescription(SR.ProcessAssociated)]
  122.         //[System.Runtime.InteropServices.ComVisible(false)]
  123.         public event DataReceivedEventHandler ErrorDataReceived;
  124.         // Abstract the stream details
  125.         internal AsyncStreamReader output;
  126.         internal AsyncStreamReader error;
  127.         internal bool pendingOutputRead;
  128.         internal bool pendingErrorRead;
  129.        
  130.        
  131.         private static SafeFileHandle InvalidPipeHandle = new SafeFileHandle(IntPtr.Zero, false);
  132.         #if DEBUG
  133.         static internal TraceSwitch processTracing = new TraceSwitch("processTracing", "Controls debug output from Process component");
  134.         #else
  135.         static internal TraceSwitch processTracing = null;
  136.         #endif
  137.        
  138.         //
  139.         // CONSTRUCTORS
  140.         //
  141.        
  142.         /// <devdoc>
  143.         /// <para>
  144.         /// Initializes a new instance of the <see cref='System.Diagnostics.Process'/> class.
  145.         /// </para>
  146.         /// </devdoc>
  147.         public Process()
  148.         {
  149.             machineName = ".";
  150.             outputStreamReadMode = StreamReadMode.undefined;
  151.             errorStreamReadMode = StreamReadMode.undefined;
  152.         }
  153.        
  154.         Process(string machineName, bool isRemoteMachine, int processId, ProcessInfo processInfo) : base()
  155.         {
  156.             Debug.Assert(SyntaxCheck.CheckMachineName(machineName), "The machine name should be valid!");
  157.             this.processInfo = processInfo;
  158.             this.machineName = machineName;
  159.             this.isRemoteMachine = isRemoteMachine;
  160.             this.processId = processId;
  161.             this.haveProcessId = true;
  162.             outputStreamReadMode = StreamReadMode.undefined;
  163.             errorStreamReadMode = StreamReadMode.undefined;
  164.         }
  165.        
  166.         //
  167.         // PROPERTIES
  168.         //
  169.        
  170.         /// <devdoc>
  171.         /// Returns whether this process component is associated with a real process.
  172.         /// </devdoc>
  173.         /// <internalonly/>
  174.         [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), MonitoringDescription(SR.ProcessAssociated)]
  175.         bool Associated {
  176.             get { return haveProcessId || haveProcessHandle; }
  177.         }
  178.        
  179.        
  180.         /// <devdoc>
  181.         /// <para>
  182.         /// Gets
  183.         /// the
  184.         /// value that was specified by the associated process when it was terminated.
  185.         /// </para>
  186.         /// </devdoc>
  187.         [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), MonitoringDescription(SR.ProcessExitCode)]
  188.         public int ExitCode {
  189.             get {
  190.                 EnsureState(State.Exited);
  191.                 return exitCode;
  192.             }
  193.         }
  194.        
  195.         /// <devdoc>
  196.         /// <para>
  197.         /// Gets a
  198.         /// value indicating whether the associated process has been terminated.
  199.         /// </para>
  200.         /// </devdoc>
  201.         [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), MonitoringDescription(SR.ProcessTerminated)]
  202.         public bool HasExited {
  203.             get {
  204.                 if (!exited) {
  205.                     EnsureState(State.Associated);
  206.                     SafeProcessHandle handle = null;
  207.                     try {
  208.                         handle = GetProcessHandle(NativeMethods.PROCESS_QUERY_INFORMATION | NativeMethods.SYNCHRONIZE, false);
  209.                         if (handle.IsInvalid) {
  210.                             exited = true;
  211.                         }
  212.                         else {
  213.                             int exitCode;
  214.                            
  215.                             if (NativeMethods.GetExitCodeProcess(handle, out exitCode) && exitCode != NativeMethods.STILL_ACTIVE) {
  216.                                 this.exited = true;
  217.                                 this.exitCode = exitCode;
  218.                             }
  219.                             else {
  220.                                
  221.                                 // The best check for exit is that the kernel process object handle is invalid,
  222.                                 // or that it is valid and signaled. Checking if the exit code != STILL_ACTIVE
  223.                                 // does not guarantee the process is closed,
  224.                                 // since some process could return an actual STILL_ACTIVE exit code (259).
  225.                                 // if we just came from WaitForExit, don't repeat
  226.                                 if (!signaled) {
  227.                                     ProcessWaitHandle wh = null;
  228.                                     try {
  229.                                         wh = new ProcessWaitHandle(handle);
  230.                                         this.signaled = wh.WaitOne(0, false);
  231.                                     }
  232.                                     finally {
  233.                                        
  234.                                         if (wh != null)
  235.                                             wh.Close();
  236.                                     }
  237.                                 }
  238.                                 if (signaled) {
  239.                                     if (!NativeMethods.GetExitCodeProcess(handle, out exitCode))
  240.                                         throw new Win32Exception();
  241.                                    
  242.                                     this.exited = true;
  243.                                     this.exitCode = exitCode;
  244.                                 }
  245.                             }
  246.                         }
  247.                     }
  248.                     finally {
  249.                         ReleaseProcessHandle(handle);
  250.                     }
  251.                    
  252.                     if (exited) {
  253.                         RaiseOnExited();
  254.                     }
  255.                 }
  256.                 return exited;
  257.             }
  258.         }
  259.        
  260.         private ProcessThreadTimes GetProcessTimes()
  261.         {
  262.             ProcessThreadTimes processTimes = new ProcessThreadTimes();
  263.             SafeProcessHandle handle = null;
  264.             try {
  265.                 handle = GetProcessHandle(NativeMethods.PROCESS_QUERY_INFORMATION, false);
  266.                 if (handle.IsInvalid) {
  267.                     // On OS older than XP, we will not be able to get the handle for a process
  268.                     // after it terminates.
  269.                     // On Windows XP and newer OS, the information about a process will stay longer.
  270.                     throw new InvalidOperationException(SR.GetString(SR.ProcessHasExited, processId.ToString(CultureInfo.CurrentCulture)));
  271.                 }
  272.                
  273.                 if (!NativeMethods.GetProcessTimes(handle, out processTimes.create, out processTimes.exit, out processTimes.kernel, out processTimes.user)) {
  274.                     throw new Win32Exception();
  275.                 }
  276.                
  277.             }
  278.             finally {
  279.                 ReleaseProcessHandle(handle);
  280.             }
  281.             return processTimes;
  282.         }
  283.        
  284.        
  285.         /// <devdoc>
  286.         /// <para>
  287.         /// Returns the native handle for the associated process. The handle is only available
  288.         /// if this component started the process.
  289.         /// </para>
  290.         /// </devdoc>
  291.         [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), MonitoringDescription(SR.ProcessHandle)]
  292.         public IntPtr Handle {
  293.             [ResourceExposure(ResourceScope.Machine)]
  294.             [ResourceConsumption(ResourceScope.Machine)]
  295.             get {
  296.                 EnsureState(State.Associated);
  297.                 return OpenProcessHandle().DangerousGetHandle();
  298.             }
  299.         }
  300.        
  301.        
  302.         /// <devdoc>
  303.         /// <para>
  304.         /// Gets
  305.         /// the unique identifier for the associated process.
  306.         /// </para>
  307.         /// </devdoc>
  308.         [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), MonitoringDescription(SR.ProcessId)]
  309.         public int Id {
  310.             get {
  311.                 EnsureState(State.HaveId);
  312.                 return processId;
  313.             }
  314.         }
  315.        
  316.         /// <devdoc>
  317.         /// <para>
  318.         /// Gets
  319.         /// the name of the computer on which the associated process is running.
  320.         /// </para>
  321.         /// </devdoc>
  322.         [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), MonitoringDescription(SR.ProcessMachineName)]
  323.         public string MachineName {
  324.             get {
  325.                 EnsureState(State.Associated);
  326.                 return machineName;
  327.             }
  328.         }
  329.        
  330.        
  331.         /// <devdoc>
  332.         /// <para>
  333.         /// Gets
  334.         /// the friendly name of the process.
  335.         /// </para>
  336.         /// </devdoc>
  337.         [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), MonitoringDescription(SR.ProcessProcessName)]
  338.         public string ProcessName {
  339.             get { return "ProcessName not implemented for PAL"; }
  340.         }
  341.        
  342.        
  343.         /// <devdoc>
  344.         /// <para>
  345.         /// Gets or sets the properties to pass into the <see cref='System.Diagnostics.Process.Start'/> method for the <see cref='System.Diagnostics.Process'/>
  346.         /// .
  347.         /// </para>
  348.         /// </devdoc>
  349.         [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Content), MonitoringDescription(SR.ProcessStartInfo)]
  350.         public ProcessStartInfo StartInfo {
  351.             get {
  352.                 if (startInfo == null) {
  353.                     startInfo = new ProcessStartInfo(this);
  354.                 }
  355.                 return startInfo;
  356.             }
  357.             set {
  358.                 if (value == null) {
  359.                     throw new ArgumentNullException("value");
  360.                 }
  361.                 startInfo = value;
  362.             }
  363.         }
  364.        
  365.        
  366.         /// <devdoc>
  367.         /// Represents the object used to marshal the event handler
  368.         /// calls issued as a result of a Process exit. Normally
  369.         /// this property will be set when the component is placed
  370.         /// inside a control or a from, since those components are
  371.         /// bound to a specific thread.
  372.         /// </devdoc>
  373.         [Browsable(false), DefaultValue(null), MonitoringDescription(SR.ProcessSynchronizingObject)]
  374.         public ISynchronizeInvoke SynchronizingObject {
  375.             get {
  376.                 if (this.synchronizingObject == null && DesignMode) {
  377.                     IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));
  378.                     if (host != null) {
  379.                         object baseComponent = host.RootComponent;
  380.                         if (baseComponent != null && baseComponent is ISynchronizeInvoke)
  381.                             this.synchronizingObject = (ISynchronizeInvoke)baseComponent;
  382.                     }
  383.                 }
  384.                
  385.                 return this.synchronizingObject;
  386.             }
  387.            
  388.             set { this.synchronizingObject = value; }
  389.         }
  390.        
  391.        
  392.         [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), MonitoringDescription(SR.ProcessVirtualMemorySize)]
  393.         [System.Runtime.InteropServices.ComVisible(false)]
  394.         public long VirtualMemorySize64 {
  395.             get {
  396.                 EnsureState(State.HaveNtProcessInfo);
  397.                 return processInfo.virtualBytes;
  398.             }
  399.         }
  400.        
  401.         /// <devdoc>
  402.         /// <para>
  403.         /// Gets or sets whether the <see cref='System.Diagnostics.Process.Exited'/>
  404.         /// event is fired
  405.         /// when the process terminates.
  406.         /// </para>
  407.         /// </devdoc>
  408.         [Browsable(false), DefaultValue(false), MonitoringDescription(SR.ProcessEnableRaisingEvents)]
  409.         public bool EnableRaisingEvents {
  410.             get { return watchForExit; }
  411.             set {
  412.                 if (value != watchForExit) {
  413.                     if (Associated) {
  414.                         if (value) {
  415.                             OpenProcessHandle();
  416.                             EnsureWatchingForExit();
  417.                         }
  418.                         else {
  419.                             StopWatchingForExit();
  420.                         }
  421.                     }
  422.                     watchForExit = value;
  423.                 }
  424.             }
  425.         }
  426.        
  427.        
  428.         /// <devdoc>
  429.         /// <para>[To be supplied.]</para>
  430.         /// </devdoc>
  431.         [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), MonitoringDescription(SR.ProcessStandardInput)]
  432.         public StreamWriter StandardInput {
  433.             get {
  434.                 if (standardInput == null) {
  435.                     throw new InvalidOperationException(SR.GetString(SR.CantGetStandardIn));
  436.                 }
  437.                
  438.                 return standardInput;
  439.             }
  440.         }
  441.        
  442.         /// <devdoc>
  443.         /// <para>[To be supplied.]</para>
  444.         /// </devdoc>
  445.         [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), MonitoringDescription(SR.ProcessStandardOutput)]
  446.         public StreamReader StandardOutput {
  447.             get {
  448.                 if (standardOutput == null) {
  449.                     throw new InvalidOperationException(SR.GetString(SR.CantGetStandardOut));
  450.                 }
  451.                
  452.                 if (outputStreamReadMode == StreamReadMode.undefined) {
  453.                     outputStreamReadMode = StreamReadMode.syncMode;
  454.                 }
  455.                 else if (outputStreamReadMode != StreamReadMode.syncMode) {
  456.                     throw new InvalidOperationException(SR.GetString(SR.CantMixSyncAsyncOperation));
  457.                 }
  458.                
  459.                 return standardOutput;
  460.             }
  461.         }
  462.        
  463.         /// <devdoc>
  464.         /// <para>[To be supplied.]</para>
  465.         /// </devdoc>
  466.         [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), MonitoringDescription(SR.ProcessStandardError)]
  467.         public StreamReader StandardError {
  468.             get {
  469.                 if (standardError == null) {
  470.                     throw new InvalidOperationException(SR.GetString(SR.CantGetStandardError));
  471.                 }
  472.                
  473.                 if (errorStreamReadMode == StreamReadMode.undefined) {
  474.                     errorStreamReadMode = StreamReadMode.syncMode;
  475.                 }
  476.                 else if (errorStreamReadMode != StreamReadMode.syncMode) {
  477.                     throw new InvalidOperationException(SR.GetString(SR.CantMixSyncAsyncOperation));
  478.                 }
  479.                
  480.                 return standardError;
  481.             }
  482.         }
  483.        
  484.        
  485.         [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), MonitoringDescription(SR.ProcessWorkingSet)]
  486.         [System.Runtime.InteropServices.ComVisible(false)]
  487.         public long WorkingSet64 {
  488.             get {
  489.                 EnsureState(State.HaveNtProcessInfo);
  490.                 return processInfo.workingSet;
  491.             }
  492.         }
  493.        
  494.         [Category("Behavior"), MonitoringDescription(SR.ProcessExited)]
  495.         public event EventHandler Exited {
  496.             add { onExited += value; }
  497.             remove { onExited -= value; }
  498.         }
  499.        
  500.        
  501.         /// <devdoc>
  502.         /// Release the temporary handle we used to get process information.
  503.         /// If we used the process handle stored in the process object (we have all access to the handle,) don't release it.
  504.         /// </devdoc>
  505.         /// <internalonly/>
  506.         void ReleaseProcessHandle(SafeProcessHandle handle)
  507.         {
  508.             if (handle == null) {
  509.                 return;
  510.             }
  511.            
  512.             if (haveProcessHandle && handle == m_processHandle) {
  513.                 return;
  514.             }
  515.             Debug.WriteLineIf(processTracing.TraceVerbose, "Process - CloseHandle(process)");
  516.             handle.Close();
  517.         }
  518.        
  519.         /// <devdoc>
  520.         /// This is called from the threadpool when a proces exits.
  521.         /// </devdoc>
  522.         /// <internalonly/>
  523.         private void CompletionCallback(object context, bool wasSignaled)
  524.         {
  525.             StopWatchingForExit();
  526.             RaiseOnExited();
  527.         }
  528.        
  529.         /// <internalonly/>
  530.         /// <devdoc>
  531.         /// <para>
  532.         /// Free any resources associated with this component.
  533.         /// </para>
  534.         /// </devdoc>
  535.         protected override void Dispose(bool disposing)
  536.         {
  537.             if (!disposed) {
  538.                 if (disposing) {
  539.                     //Dispose managed and unmanaged resources
  540.                     Close();
  541.                 }
  542.                 this.disposed = true;
  543.                 base.Dispose(disposing);
  544.             }
  545.         }
  546.        
  547.         /// <devdoc>
  548.         /// <para>
  549.         /// Frees any resources associated with this component.
  550.         /// </para>
  551.         /// </devdoc>
  552.         public void Close()
  553.         {
  554.             if (Associated) {
  555.                 if (haveProcessHandle) {
  556.                     StopWatchingForExit();
  557.                     Debug.WriteLineIf(processTracing.TraceVerbose, "Process - CloseHandle(process) in Close()");
  558.                     m_processHandle.Close();
  559.                     m_processHandle = null;
  560.                     haveProcessHandle = false;
  561.                 }
  562.                 haveProcessId = false;
  563.                 isRemoteMachine = false;
  564.                 machineName = ".";
  565.                 raisedOnExited = false;
  566.                
  567.                 //Don't call close on the Readers and writers
  568.                 //since they might be referenced by somebody else while the
  569.                 //process is still alive but this method called.
  570.                 standardOutput = null;
  571.                 standardInput = null;
  572.                 standardError = null;
  573.                
  574.                
  575.                 Refresh();
  576.             }
  577.         }
  578.        
  579.         /// <devdoc>
  580.         /// Helper method for checking preconditions when accessing properties.
  581.         /// </devdoc>
  582.         /// <internalonly/>
  583.         void EnsureState(State state)
  584.         {
  585.             if ((state & State.IsWin2k) != (State)0) {
  586.                 throw new PlatformNotSupportedException(SR.GetString(SR.Win2kRequired));
  587.             }
  588.            
  589.             if ((state & State.IsNt) != (State)0) {
  590.                 throw new PlatformNotSupportedException(SR.GetString(SR.WinNTRequired));
  591.             }
  592.            
  593.             if ((state & State.Associated) != (State)0)
  594.                 if (!Associated)
  595.                     throw new InvalidOperationException(SR.GetString(SR.NoAssociatedProcess));
  597.            
  598.             if ((state & State.HaveId) != (State)0) {
  599.                 if (!haveProcessId) {
  600.                     EnsureState(State.Associated);
  601.                     throw new InvalidOperationException(SR.GetString(SR.ProcessIdRequired));
  602.                 }
  603.             }
  604.            
  605.             if ((state & State.IsLocal) != (State)0 && isRemoteMachine) {
  606.                 throw new NotSupportedException(SR.GetString(SR.NotSupportedRemote));
  607.             }
  608.            
  609.             if ((state & State.HaveProcessInfo) != (State)0) {
  610.                 throw new InvalidOperationException(SR.GetString(SR.NoProcessInfo));
  611.             }
  612.            
  613.             if ((state & State.Exited) != (State)0) {
  614.                 if (!HasExited) {
  615.                     throw new InvalidOperationException(SR.GetString(SR.WaitTillExit));
  616.                 }
  617.                
  618.                 if (!haveProcessHandle) {
  619.                     throw new InvalidOperationException(SR.GetString(SR.NoProcessHandle));
  620.                 }
  621.             }
  622.         }
  623.        
  624.         /// <devdoc>
  625.         /// Make sure we are watching for a process exit.
  626.         /// </devdoc>
  627.         /// <internalonly/>
  628.         void EnsureWatchingForExit()
  629.         {
  630.             if (!watchingForExit) {
  631.                 Debug.Assert(haveProcessHandle, "Process.EnsureWatchingForExit called with no process handle");
  632.                 Debug.Assert(Associated, "Process.EnsureWatchingForExit called with no associated process");
  633.                 watchingForExit = true;
  634.                 try {
  635.                     this.waitHandle = new ProcessWaitHandle(m_processHandle);
  636.                     this.registeredWaitHandle = ThreadPool.RegisterWaitForSingleObject(this.waitHandle, new WaitOrTimerCallback(this.CompletionCallback), null, -1, true);
  637.                 }
  638.                 catch {
  639.                     watchingForExit = false;
  640.                     throw;
  641.                 }
  642.             }
  643.         }
  644.        
  645.        
  646.         /// <devdoc>
  647.         /// <para>
  648.         /// Returns a new <see cref='System.Diagnostics.Process'/>
  649.         /// component and associates it with the current active process.
  650.         /// </para>
  651.         /// </devdoc>
  652.         public static Process GetCurrentProcess()
  653.         {
  654.             return new Process(".", false, NativeMethods.GetCurrentProcessId(), null);
  655.         }
  656.        
  657.         /// <devdoc>
  658.         /// <para>
  659.         /// Raises the <see cref='System.Diagnostics.Process.Exited'/> event.
  660.         /// </para>
  661.         /// </devdoc>
  662.         protected void OnExited()
  663.         {
  664.             EventHandler exited = onExited;
  665.             if (exited != null) {
  666.                 if (this.SynchronizingObject != null && this.SynchronizingObject.InvokeRequired)
  667.                     this.SynchronizingObject.BeginInvoke(exited, new object[] {this, EventArgs.Empty});
  668.                 else
  669.                     exited(this, EventArgs.Empty);
  670.             }
  671.         }
  672.        
  673.         /// <devdoc>
  674.         /// Gets a short-term handle to the process, with the given access.
  675.         /// If a handle is stored in current process object, then use it.
  676.         /// Note that the handle we stored in current process object will have all access we need.
  677.         /// </devdoc>
  678.         /// <internalonly/>
  679.         SafeProcessHandle GetProcessHandle(int access, bool throwIfExited)
  680.         {
  681.             Debug.WriteLineIf(processTracing.TraceVerbose, "GetProcessHandle(access = 0x" + access.ToString("X8", CultureInfo.InvariantCulture) + ", throwIfExited = " + throwIfExited + ")");
  682.             #if DEBUG
  683.             if (processTracing.TraceVerbose) {
  684.                 StackFrame calledFrom = new StackTrace(true).GetFrame(0);
  685.                 Debug.WriteLine(" called from " + calledFrom.GetFileName() + ", line " + calledFrom.GetFileLineNumber());
  686.             }
  687.             #endif
  688.             if (haveProcessHandle) {
  689.                 if (throwIfExited) {
  690.                     // Since haveProcessHandle is true, we know we have the process handle
  691.                     // open with at least SYNCHRONIZE access, so we can wait on it with
  692.                     // zero timeout to see if the process has exited.
  693.                     ProcessWaitHandle waitHandle = null;
  694.                     try {
  695.                         waitHandle = new ProcessWaitHandle(m_processHandle);
  696.                         if (waitHandle.WaitOne(0, false)) {
  697.                             if (haveProcessId)
  698.                                 throw new InvalidOperationException(SR.GetString(SR.ProcessHasExited, processId.ToString(CultureInfo.CurrentCulture)));
  699.                             else
  700.                                 throw new InvalidOperationException(SR.GetString(SR.ProcessHasExitedNoId));
  701.                         }
  702.                     }
  703.                     finally {
  704.                         if (waitHandle != null) {
  705.                             waitHandle.Close();
  706.                         }
  707.                     }
  708.                 }
  709.                 return m_processHandle;
  710.             }
  711.             else {
  712.                 EnsureState(State.HaveId | State.IsLocal);
  713.                 SafeProcessHandle handle = SafeProcessHandle.InvalidHandle;
  714.                 IntPtr pseudohandle = NativeMethods.GetCurrentProcess();
  715.                 // Get a real handle
  716.                 if (!NativeMethods.DuplicateHandle(new HandleRef(this, pseudohandle), new HandleRef(this, pseudohandle), new HandleRef(this, pseudohandle), out handle, 0, false, NativeMethods.DUPLICATE_SAME_ACCESS | NativeMethods.DUPLICATE_CLOSE_SOURCE)) {
  717.                     throw new Win32Exception();
  718.                 }
  719.                 if (throwIfExited && (access & NativeMethods.PROCESS_QUERY_INFORMATION) != 0) {
  720.                     if (NativeMethods.GetExitCodeProcess(handle, out exitCode) && exitCode != NativeMethods.STILL_ACTIVE) {
  721.                         throw new InvalidOperationException(SR.GetString(SR.ProcessHasExited, processId.ToString(CultureInfo.CurrentCulture)));
  722.                     }
  723.                 }
  724.                 return handle;
  725.             }
  726.            
  727.         }
  728.        
  729.         /// <devdoc>
  730.         /// Gets a short-term handle to the process, with the given access. If a handle exists,
  731.         /// then it is reused. If the process has exited, it throws an exception.
  732.         /// </devdoc>
  733.         /// <internalonly/>
  734.         SafeProcessHandle GetProcessHandle(int access)
  735.         {
  736.             return GetProcessHandle(access, true);
  737.         }
  738.        
  739.         /// <devdoc>
  740.         /// Opens a long-term handle to the process, with all access. If a handle exists,
  741.         /// then it is reused. If the process has exited, it throws an exception.
  742.         /// </devdoc>
  743.         /// <internalonly/>
  744.         SafeProcessHandle OpenProcessHandle()
  745.         {
  746.             if (!haveProcessHandle) {
  747.                 //Cannot open a new process handle if the object has been disposed, since finalization has been suppressed.
  748.                 if (this.disposed) {
  749.                     throw new ObjectDisposedException(GetType().Name);
  750.                 }
  751.                
  752.                 SetProcessHandle(GetProcessHandle(NativeMethods.PROCESS_ALL_ACCESS));
  753.             }
  754.             return m_processHandle;
  755.         }
  756.        
  757.         /// <devdoc>
  758.         /// Raise the Exited event, but make sure we don't do it more than once.
  759.         /// </devdoc>
  760.         /// <internalonly/>
  761.         void RaiseOnExited()
  762.         {
  763.             if (!raisedOnExited) {
  764.                 lock (this) {
  765.                     if (!raisedOnExited) {
  766.                         raisedOnExited = true;
  767.                         OnExited();
  768.                     }
  769.                 }
  770.             }
  771.         }
  772.        
  773.         /// <devdoc>
  774.         /// <para>
  775.         /// Discards any information about the associated process
  776.         /// that has been cached inside the process component. After <see cref='System.Diagnostics.Process.Refresh'/> is called, the
  777.         /// first request for information for each property causes the process component
  778.         /// to obtain a new value from the associated process.
  779.         /// </para>
  780.         /// </devdoc>
  781.         public void Refresh()
  782.         {
  783.             processInfo = null;
  784.             mainWindowTitle = null;
  785.             exited = false;
  786.             signaled = false;
  787.             haveMainWindow = false;
  788.             haveWorkingSetLimits = false;
  789.             haveProcessorAffinity = false;
  790.             havePriorityClass = false;
  791.             haveExitTime = false;
  792.             haveResponding = false;
  793.             havePriorityBoostEnabled = false;
  794.         }
  795.        
  796.         /// <devdoc>
  797.         /// Helper to associate a process handle with this component.
  798.         /// </devdoc>
  799.         /// <internalonly/>
  800.         void SetProcessHandle(SafeProcessHandle processHandle)
  801.         {
  802.             this.m_processHandle = processHandle;
  803.             this.haveProcessHandle = true;
  804.