C# IProcess.Kill方法代码示例

        public static Task StopProcessAsync(IProcess process)
        {
            if (process == null)
                return Task.FromResult<object>(null);

            return Task.Run(() => process.Kill());
        }

 public async Task StopProcess(IProcess process)
 {
     string exePath = process.ExePath;
     try
     {
         if (!await StopGracefully(process))
         {
             Trace.TraceInformation(
                 "Process has not exited gracefully or is not listening to the stop event, let's try to close the main window");
             if (!await Close(process))
             {
                 Trace.TraceInformation("The host process would not close, attempting to kill");
                 await process.Kill();
                 Trace.TraceInformation("The host process was killed");
             }
             else
             {
                 Trace.TraceInformation("Process exited with CloseMainWindow");
             }
         }
         else
         {
             Trace.TraceInformation("Process exited gracefully");
         }
         await process.ReleaseResources();
         await Task.Delay(ReleaseResourcesDelayMilliseconds); // allowing the os some time to release resources
     }
     catch (Exception ex)
     {
         // there is nothing more we can do; we'll swallow the exception and log an error
         Trace.TraceError("{0} host process could not be killed. Exception was: {1}", exePath, ex);
     }
 }

        internal void WaitForExit(IProcess process)
        {
            DateTime lastActivity = _lastActivity;
            DateTime lastCpuActivity = _lastActivity;
            TimeSpan previousCpuUsage = _initialCpuUsage;

            while (!process.WaitForExit(TimeSpan.FromSeconds(1)))
            {
                // there is IO activity, continue to wait.
                if (lastActivity != _lastActivity)
                {
                    // there is io activity, reset cpu to initial
                    previousCpuUsage = _initialCpuUsage;
                    lastActivity = _lastActivity;
                    continue;
                }

                // Check how long it's been since the last IO activity
                TimeSpan idleTime = DateTime.UtcNow - lastActivity;

                // If less than the timeout, do nothing
                if (idleTime < _idleTimeout) continue;

                // Write progress to prevent client timeouts
                WriteProgress();

                // There wasn't any IO activity. Check if we had any CPU activity

                // Check how long it's been since the last CPU activity
                TimeSpan cpuIdleTime = DateTime.UtcNow - lastCpuActivity;

                // If less than the timeout, do nothing
                if (cpuIdleTime < _idleTimeout) continue;

                TimeSpan currentCpuUsage = process.GetTotalProcessorTime(_tracer);

                _tracer.Trace("{0}: no io activity for {1:0}s, prev-cpu={2:0.000}s, current-cpu={3:0.000}s", 
                    process.Name, 
                    idleTime.TotalSeconds,
                    previousCpuUsage.TotalSeconds,
                    currentCpuUsage.TotalSeconds);

                if (currentCpuUsage != previousCpuUsage)
                {
                    // The process performed some compute bound operation.  We'll wait for it some more
                    lastCpuActivity = DateTime.UtcNow;
                    previousCpuUsage = currentCpuUsage;
                    continue;
                }

                // It's likely that the process is idling waiting for user input. Kill it
                process.Kill(_tracer);

                throw CreateIdleTimeoutException(process, cpuIdleTime);
            }

            process.WaitUntilEOF();
        }