親プロセスが殺されたときに子プロセスを殺す
アプリケーションのSystem.Diagnostics.Processクラスを使用して新しいプロセスを作成しています。
アプリケーションがクラッシュした場合、またはクラッシュした場合、このプロセスを強制終了します。ただし、タスクマネージャーからアプリケーションを強制終了しても、子プロセスは強制終了されません。
子プロセスを親プロセスに依存させる方法はありますか？
このフォーラム から、 'Josh'へのクレジット。
Application.Quit()およびProcess.Kill()は可能な解決策ですが、信頼できないことが証明されています。メインアプリケーションが終了しても、子プロセスは実行されたままです。私たちが本当に望んでいるのは、メインプロセスが終了するとすぐに子プロセスが終了することです。
解決策は、「ジョブオブジェクト」 http://msdn.Microsoft.com/en-us/library/ms682409（VS.85）.aspx を使用することです。
メインアプリケーションの「ジョブオブジェクト」を作成し、子プロセスをジョブオブジェクトに登録するという考え方です。メインプロセスが停止した場合、OSは子プロセスの終了を処理します。
public enum JobObjectInfoType
{
AssociateCompletionPortInformation = 7,
BasicLimitInformation = 2,
BasicUIRestrictions = 4,
EndOfJobTimeInformation = 6,
ExtendedLimitInformation = 9,
SecurityLimitInformation = 5,
GroupInformation = 11
}
[StructLayout(LayoutKind.Sequential)]
public struct SECURITY_ATTRIBUTES
{
public int nLength;
public IntPtr lpSecurityDescriptor;
public int bInheritHandle;
}
[StructLayout(LayoutKind.Sequential)]
struct JOBOBJECT_BASIC_LIMIT_INFORMATION
{
public Int64 PerProcessUserTimeLimit;
public Int64 PerJobUserTimeLimit;
public Int16 LimitFlags;
public UInt32 MinimumWorkingSetSize;
public UInt32 MaximumWorkingSetSize;
public Int16 ActiveProcessLimit;
public Int64 Affinity;
public Int16 PriorityClass;
public Int16 SchedulingClass;
}
[StructLayout(LayoutKind.Sequential)]
struct IO_COUNTERS
{
public UInt64 ReadOperationCount;
public UInt64 WriteOperationCount;
public UInt64 OtherOperationCount;
public UInt64 ReadTransferCount;
public UInt64 WriteTransferCount;
public UInt64 OtherTransferCount;
}
[StructLayout(LayoutKind.Sequential)]
struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION
{
public JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
public IO_COUNTERS IoInfo;
public UInt32 ProcessMemoryLimit;
public UInt32 JobMemoryLimit;
public UInt32 PeakProcessMemoryUsed;
public UInt32 PeakJobMemoryUsed;
}
public class Job : IDisposable
{
[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
static extern IntPtr CreateJobObject(object a, string lpName);
[DllImport("kernel32.dll")]
static extern bool SetInformationJobObject(IntPtr hJob, JobObjectInfoType infoType, IntPtr lpJobObjectInfo, uint cbJobObjectInfoLength);
[DllImport("kernel32.dll", SetLastError = true)]
static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
private IntPtr m_handle;
private bool m_disposed = false;
public Job()
{
m_handle = CreateJobObject(null, null);
JOBOBJECT_BASIC_LIMIT_INFORMATION info = new JOBOBJECT_BASIC_LIMIT_INFORMATION();
info.LimitFlags = 0x2000;
JOBOBJECT_EXTENDED_LIMIT_INFORMATION extendedInfo = new JOBOBJECT_EXTENDED_LIMIT_INFORMATION();
extendedInfo.BasicLimitInformation = info;
int length = Marshal.SizeOf(typeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION));
IntPtr extendedInfoPtr = Marshal.AllocHGlobal(length);
Marshal.StructureToPtr(extendedInfo, extendedInfoPtr, false);
if (!SetInformationJobObject(m_handle, JobObjectInfoType.ExtendedLimitInformation, extendedInfoPtr, (uint)length))
throw new Exception(string.Format("Unable to set information. Error: {0}", Marshal.GetLastWin32Error()));
}
#region IDisposable Members
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
#endregion
private void Dispose(bool disposing)
{
if (m_disposed)
return;
if (disposing) {}
Close();
m_disposed = true;
}
public void Close()
{
Win32.CloseHandle(m_handle);
m_handle = IntPtr.Zero;
}
public bool AddProcess(IntPtr handle)
{
return AssignProcessToJobObject(m_handle, handle);
}
}
コンストラクターを見ると...
JOBOBJECT_BASIC_LIMIT_INFORMATION info = new JOBOBJECT_BASIC_LIMIT_INFORMATION();
info.LimitFlags = 0x2000;
ここで重要なのは、ジョブオブジェクトを適切に設定することです。コンストラクターで、「制限」を0x2000に設定しています。これは、JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSEの数値です。
MSDNはこのフラグを次のように定義しています。
ジョブの最後のハンドルが閉じられると、ジョブに関連付けられているすべてのプロセスが終了します。
このクラスをセットアップしたら...各子プロセスをジョブに登録するだけです。例えば：
[DllImport("user32.dll", SetLastError = true)]
public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
Excel.Application app = new Excel.ApplicationClass();
uint pid = 0;
Win32.GetWindowThreadProcessId(new IntPtr(app.Hwnd), out pid);
job.AddProcess(Process.GetProcessById((int)pid).Handle);
この投稿は、@ Matt Howellsの回答を拡張することを目的としています。特に、VistaまたはWin7でジョブオブジェクトを使用する際に問題が発生した場合は、特にAssignProcessToJobObjectを呼び出すと、アクセス拒否エラー（ '5'）が発生します。
tl; dr
VistaおよびWin7との互換性を確保するには、次のマニフェストを.NET親プロセスに追加します。
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<Assembly xmlns="urn:schemas-Microsoft-com:asm.v1" manifestVersion="1.0">
<v3:trustInfo xmlns:v3="urn:schemas-Microsoft-com:asm.v3">
<v3:security>
<v3:requestedPrivileges>
<v3:requestedExecutionLevel level="asInvoker" uiAccess="false" />
</v3:requestedPrivileges>
</v3:security>
</v3:trustInfo>
<compatibility xmlns="urn:schemas-Microsoft-com:compatibility.v1">
<!-- We specify these, in addition to the UAC above, so we avoid Program Compatibility Assistant in Vista and Win7 -->
<!-- We try to avoid PCA so we can use Windows Job Objects -->
<!-- See https://stackoverflow.com/questions/3342941/kill-child-process-when-parent-process-is-killed -->
<application>
<!--The ID below indicates application support for Windows Vista -->
<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
<!--The ID below indicates application support for Windows 7 -->
<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
</application>
</compatibility>
</Assembly>
Visual Studio 2012で新しいマニフェストを追加すると、上記のスニペットが既に含まれているため、Hearからコピーする必要はありません。また、Windows 8のノードも含まれます。
完全な説明
開始するプロセスが既に別のジョブに関連付けられている場合、ジョブの関連付けはアクセス拒否エラーで失敗します。プログラム互換性アシスタントを起動します。WindowsVista以降では、すべての種類のプロセスを独自のジョブに割り当てます。
Vistaでは、アプリケーションマニフェストを含めるだけで、PCAから除外するようにアプリケーションをマークできます。 Visual Studioは.NETアプリに対してこれを自動的に行うように思われるので、そこは大丈夫です。
単純なマニフェストは、Win7でそれをカットしなくなりました。 [1]そこで、Win7と互換性があることをマニフェストのタグで具体的に指定する必要があります。 [2]
これにより、Windows 8について心配することになりました。マニフェストをもう一度変更する必要がありますか？ Windows 8では、プロセスが複数のジョブに属することができるようになったため、クラウドにブレークが生じたようです。 [3]したがって、まだテストしていませんが、supportedOS情報を含むマニフェストを含めるだけで、この狂気はもう終わっていると思います。
ヒント1：Visual Studioで.NETアプリを開発している場合、私と同じように、ここ[4]にカスタマイズ方法に関する素敵な指示がありますアプリケーションマニフェスト。
ヒント2：Visual Studioからのアプリケーションの起動には注意してください。適切なマニフェストを追加した後、デバッグなしで開始を使用した場合でも、Visual Studioから起動するときにPCAで問題が発生することがわかりました。ただし、エクスプローラからアプリケーションを起動することはできました。レジストリを使用してPCAから除外するためにdevenvを手動で追加した後、VSからジョブオブジェクトを使用するアプリケーションを起動することも開始しました。 [5]
ヒント3：PCAが問題かどうかを知りたい場合は、コマンドラインからアプリケーションを起動するか、プログラムをネットワークドライブにコピーしてくださいそこから実行します。これらのコンテキストでは、PCAは自動的に無効になります。
[2] http://ayende.com/blog/4360/how-to-opt-out-of-program-compatibility-assistant
[3] http://msdn.Microsoft.com/en-us/library/windows/desktop/ms681949（v = vs.85）.aspx ：「プロセスは複数のWindows 8で1つのジョブ」
この回答は、 @ Matt Howellsの優れた回答 に加えて他の回答から始まりました（以下のコードのリンクを参照）。改善点：
- 32ビットおよび64ビットをサポートします。
- @Matt Howellsの回答のいくつかの問題を修正します。
extendedInfoPtrの小さなメモリリーク- 'Win32'コンパイルエラー、および
CreateJobObject（Windows 10、Visual Studio 2015、32ビットを使用）への呼び出しで取得したスタックアンバランス例外。
- ジョブに名前を付けるので、たとえばSysInternalsを使用すると、簡単に見つけることができます。
- ややシンプルなAPIと少ないコードを備えています。
このコードの使用方法は次のとおりです。
// Get a Process object somehow.
Process process = Process.Start(exePath, args);
// Add the Process to ChildProcessTracker.
ChildProcessTracker.AddProcess(process);
Windows 7をサポートするには、次のものが必要です。
- @ adam smithの説明 のような単純なapp.manifestの変更。
- 追加するレジストリ設定 Visual Studioを使用している場合。
私の場合、Windows 7をサポートする必要はなかったので、以下の静的コンストラクターの上部に簡単なチェックがあります。
/// <summary>
/// Allows processes to be automatically killed if this parent process unexpectedly quits.
/// This feature requires Windows 8 or greater. On Windows 7, nothing is done.</summary>
/// <remarks>References:
/// https://stackoverflow.com/a/4657392/386091
/// https://stackoverflow.com/a/9164742/386091 </remarks>
public static class ChildProcessTracker
{
/// <summary>
/// Add the process to be tracked. If our current process is killed, the child processes
/// that we are tracking will be automatically killed, too. If the child process terminates
/// first, that's fine, too.</summary>
/// <param name="process"></param>
public static void AddProcess(Process process)
{
if (s_jobHandle != IntPtr.Zero)
{
bool success = AssignProcessToJobObject(s_jobHandle, process.Handle);
if (!success && !process.HasExited)
throw new Win32Exception();
}
}
static ChildProcessTracker()
{
// This feature requires Windows 8 or later. To support Windows 7 requires
// registry settings to be added if you are using Visual Studio plus an
// app.manifest change.
// https://stackoverflow.com/a/4232259/386091
// https://stackoverflow.com/a/9507862/386091
if (Environment.OSVersion.Version < new Version(6, 2))
return;
// The job name is optional (and can be null) but it helps with diagnostics.
// If it's not null, it has to be unique. Use SysInternals' Handle command-line
// utility: handle -a ChildProcessTracker
string jobName = "ChildProcessTracker" + Process.GetCurrentProcess().Id;
s_jobHandle = CreateJobObject(IntPtr.Zero, jobName);
var info = new JOBOBJECT_BASIC_LIMIT_INFORMATION();
// This is the key flag. When our process is killed, Windows will automatically
// close the job handle, and when that happens, we want the child processes to
// be killed, too.
info.LimitFlags = JOBOBJECTLIMIT.JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
var extendedInfo = new JOBOBJECT_EXTENDED_LIMIT_INFORMATION();
extendedInfo.BasicLimitInformation = info;
int length = Marshal.SizeOf(typeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION));
IntPtr extendedInfoPtr = Marshal.AllocHGlobal(length);
try
{
Marshal.StructureToPtr(extendedInfo, extendedInfoPtr, false);
if (!SetInformationJobObject(s_jobHandle, JobObjectInfoType.ExtendedLimitInformation,
extendedInfoPtr, (uint)length))
{
throw new Win32Exception();
}
}
finally
{
Marshal.FreeHGlobal(extendedInfoPtr);
}
}
[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
static extern IntPtr CreateJobObject(IntPtr lpJobAttributes, string name);
[DllImport("kernel32.dll")]
static extern bool SetInformationJobObject(IntPtr job, JobObjectInfoType infoType,
IntPtr lpJobObjectInfo, uint cbJobObjectInfoLength);
[DllImport("kernel32.dll", SetLastError = true)]
static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
// Windows will automatically close any open job handles when our process terminates.
// This can be verified by using SysInternals' Handle utility. When the job handle
// is closed, the child processes will be killed.
private static readonly IntPtr s_jobHandle;
}
public enum JobObjectInfoType
{
AssociateCompletionPortInformation = 7,
BasicLimitInformation = 2,
BasicUIRestrictions = 4,
EndOfJobTimeInformation = 6,
ExtendedLimitInformation = 9,
SecurityLimitInformation = 5,
GroupInformation = 11
}
[StructLayout(LayoutKind.Sequential)]
public struct JOBOBJECT_BASIC_LIMIT_INFORMATION
{
public Int64 PerProcessUserTimeLimit;
public Int64 PerJobUserTimeLimit;
public JOBOBJECTLIMIT LimitFlags;
public UIntPtr MinimumWorkingSetSize;
public UIntPtr MaximumWorkingSetSize;
public UInt32 ActiveProcessLimit;
public Int64 Affinity;
public UInt32 PriorityClass;
public UInt32 SchedulingClass;
}
[Flags]
public enum JOBOBJECTLIMIT : uint
{
JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x2000
}
[StructLayout(LayoutKind.Sequential)]
public struct IO_COUNTERS
{
public UInt64 ReadOperationCount;
public UInt64 WriteOperationCount;
public UInt64 OtherOperationCount;
public UInt64 ReadTransferCount;
public UInt64 WriteTransferCount;
public UInt64 OtherTransferCount;
}
[StructLayout(LayoutKind.Sequential)]
public struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION
{
public JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
public IO_COUNTERS IoInfo;
public UIntPtr ProcessMemoryLimit;
public UIntPtr JobMemoryLimit;
public UIntPtr PeakProcessMemoryUsed;
public UIntPtr PeakJobMemoryUsed;
}
マネージバージョンとネイティブバージョンを互いにプログラムで比較することで、構造体の32ビットバージョンと64ビットバージョンの両方を慎重にテストしました（全体のサイズと各メンバーのオフセット）。
このコードをWindows 7、8、および10でテストしました。
以下は、子プロセスが実行するコードを制御できる場合に機能する代替手段です。このアプローチの利点は、ネイティブのWindows呼び出しを必要としないことです。
基本的な考え方は、子の標準入力をもう一方の端が親に接続されているストリームにリダイレクトし、そのストリームを使用して親がなくなったことを検出することです。 System.Diagnostics.Processを使用して子を開始すると、その標準入力がリダイレクトされることを簡単に確認できます。
Process childProcess = new Process();
childProcess.StartInfo = new ProcessStartInfo("pathToConsoleModeApp.exe");
childProcess.StartInfo.RedirectStandardInput = true;
childProcess.StartInfo.CreateNoWindow = true; // no sense showing an empty black console window which the user can't input into
そして、子プロセスでは、標準入力ストリームからのReadsが、ストリームが閉じられるまで、少なくとも1バイトで常に返されるという事実を利用します。私がこれを行うことになった方法の概要を以下に示します。私の方法では、メッセージポンプを使用して、標準の監視以外の目的でメインスレッドを使用できるようにしますが、この一般的なアプローチはメッセージポンプなしでも使用できます。
using System;
using System.IO;
using System.Threading;
using System.Windows.Forms;
static int Main()
{
Application.Run(new MyApplicationContext());
return 0;
}
public class MyApplicationContext : ApplicationContext
{
private SynchronizationContext _mainThreadMessageQueue = null;
private Stream _stdInput;
public MyApplicationContext()
{
_stdInput = Console.OpenStandardInput();
// feel free to use a better way to post to the message loop from here if you know one ;)
System.Windows.Forms.Timer handoffToMessageLoopTimer = new System.Windows.Forms.Timer();
handoffToMessageLoopTimer.Interval = 1;
handoffToMessageLoopTimer.Tick += new EventHandler((obj, eArgs) => { PostMessageLoopInitialization(handoffToMessageLoopTimer); });
handoffToMessageLoopTimer.Start();
}
private void PostMessageLoopInitialization(System.Windows.Forms.Timer t)
{
if (_mainThreadMessageQueue == null)
{
t.Stop();
_mainThreadMessageQueue = SynchronizationContext.Current;
}
// constantly monitor standard input on a background thread that will
// signal the main thread when stuff happens.
BeginMonitoringStdIn(null);
// start up your application's real work here
}
private void BeginMonitoringStdIn(object state)
{
if (SynchronizationContext.Current == _mainThreadMessageQueue)
{
// we're already running on the main thread - proceed.
var buffer = new byte[128];
_stdInput.BeginRead(buffer, 0, buffer.Length, (asyncResult) =>
{
int amtRead = _stdInput.EndRead(asyncResult);
if (amtRead == 0)
{
_mainThreadMessageQueue.Post(new SendOrPostCallback(ApplicationTeardown), null);
}
else
{
BeginMonitoringStdIn(null);
}
}, null);
}
else
{
// not invoked from the main thread - dispatch another call to this method on the main thread and return
_mainThreadMessageQueue.Post(new SendOrPostCallback(BeginMonitoringStdIn), null);
}
}
private void ApplicationTeardown(object state)
{
// tear down your application gracefully here
_stdInput.Close();
this.ExitThread();
}
}
このアプローチの注意事項：
起動される実際の子.exeはコンソールアプリケーションである必要があるため、stdin/out/errにアタッチされたままになります。上記の例のように、既存のプロジェクトを参照する小さなコンソールプロジェクトを作成し、アプリケーションコンテキストをインスタンス化して
Application.Run()を呼び出すだけで、メッセージポンプを使用した既存のアプリケーションを簡単に適合させました（GUIは表示しませんでした）コンソール.exeのMainメソッド内。技術的には、これは単にsignals親が終了するときの子プロセスなので、親プロセスが正常に終了したかクラッシュしたかに関わらず動作しますが、独自のシャットダウンを実行するのはまだ子プロセス次第です。これはあなたが望むものかもしれませんし、そうでないかもしれません...
1つの方法は、親プロセスのPIDを子に渡すことです。指定されたpidを持つプロセスが存在するかどうか、子は定期的にポーリングします。そうでない場合は、終了します。
また、子プロセスで Process.WaitForExit メソッドを使用して、親プロセスが終了したときに通知を受けることもできますが、タスクマネージャーの場合は機能しない可能性があります。
プログラムの終了時に子プロセスを終了するための、簡単で効果的な別の関連する方法があります。親からデバッガーを実装してデバッガーにアタッチできます。親プロセスが終了すると、子プロセスはOSによって強制終了されます。子から親にデバッガをアタッチするには、両方の方法を使用できます（一度にアタッチできるデバッガは1つだけです）。この件に関する詳細情報を見つけることができます こちら 。
ここには、新しいプロセスを起動し、それにデバッガーをアタッチするユーティリティクラスがあります。 Roger Knappによる この投稿 から改作されました。唯一の要件は、両方のプロセスが同じビット数を共有する必要があることです。 64ビットプロセスから32ビットプロセスをデバッグしたり、その逆を行うことはできません。
public class ProcessRunner
{
#region "API imports"
private const int DBG_CONTINUE = 0x00010002;
private const int DBG_EXCEPTION_NOT_HANDLED = unchecked((int) 0x80010001);
private enum DebugEventType : int
{
CREATE_PROCESS_DEBUG_EVENT = 3,
//Reports a create-process debugging event. The value of u.CreateProcessInfo specifies a CREATE_PROCESS_DEBUG_INFO structure.
CREATE_THREAD_DEBUG_EVENT = 2,
//Reports a create-thread debugging event. The value of u.CreateThread specifies a CREATE_THREAD_DEBUG_INFO structure.
EXCEPTION_DEBUG_EVENT = 1,
//Reports an exception debugging event. The value of u.Exception specifies an EXCEPTION_DEBUG_INFO structure.
EXIT_PROCESS_DEBUG_EVENT = 5,
//Reports an exit-process debugging event. The value of u.ExitProcess specifies an EXIT_PROCESS_DEBUG_INFO structure.
EXIT_THREAD_DEBUG_EVENT = 4,
//Reports an exit-thread debugging event. The value of u.ExitThread specifies an EXIT_THREAD_DEBUG_INFO structure.
LOAD_DLL_DEBUG_EVENT = 6,
//Reports a load-dynamic-link-library (DLL) debugging event. The value of u.LoadDll specifies a LOAD_DLL_DEBUG_INFO structure.
OUTPUT_DEBUG_STRING_EVENT = 8,
//Reports an output-debugging-string debugging event. The value of u.DebugString specifies an OUTPUT_DEBUG_STRING_INFO structure.
RIP_EVENT = 9,
//Reports a RIP-debugging event (system debugging error). The value of u.RipInfo specifies a RIP_INFO structure.
UNLOAD_DLL_DEBUG_EVENT = 7,
//Reports an unload-DLL debugging event. The value of u.UnloadDll specifies an UNLOAD_DLL_DEBUG_INFO structure.
}
[StructLayout(LayoutKind.Sequential)]
private struct DEBUG_EVENT
{
[MarshalAs(UnmanagedType.I4)] public DebugEventType dwDebugEventCode;
public int dwProcessId;
public int dwThreadId;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1024)] public byte[] bytes;
}
[DllImport("Kernel32.dll", SetLastError = true)]
private static extern bool DebugActiveProcess(int dwProcessId);
[DllImport("Kernel32.dll", SetLastError = true)]
private static extern bool WaitForDebugEvent([Out] out DEBUG_EVENT lpDebugEvent, int dwMilliseconds);
[DllImport("Kernel32.dll", SetLastError = true)]
private static extern bool ContinueDebugEvent(int dwProcessId, int dwThreadId, int dwContinueStatus);
[DllImport("Kernel32.dll", SetLastError = true)]
public static extern bool IsDebuggerPresent();
#endregion
public Process ChildProcess { get; set; }
public bool StartProcess(string fileName)
{
var processStartInfo = new ProcessStartInfo(fileName)
{
UseShellExecute = false,
WindowStyle = ProcessWindowStyle.Normal,
ErrorDialog = false
};
this.ChildProcess = Process.Start(processStartInfo);
if (ChildProcess == null)
return false;
new Thread(NullDebugger) {IsBackground = true}.Start(ChildProcess.Id);
return true;
}
private void NullDebugger(object arg)
{
// Attach to the process we provided the thread as an argument
if (DebugActiveProcess((int) arg))
{
var debugEvent = new DEBUG_EVENT {bytes = new byte[1024]};
while (!this.ChildProcess.HasExited)
{
if (WaitForDebugEvent(out debugEvent, 1000))
{
// return DBG_CONTINUE for all events but the exception type
var continueFlag = DBG_CONTINUE;
if (debugEvent.dwDebugEventCode == DebugEventType.EXCEPTION_DEBUG_EVENT)
continueFlag = DBG_EXCEPTION_NOT_HANDLED;
ContinueDebugEvent(debugEvent.dwProcessId, debugEvent.dwThreadId, continueFlag);
}
}
}
else
{
//we were not able to attach the debugger
//do the processes have the same bitness?
//throw ApplicationException("Unable to attach debugger") // Kill child? // Send Event? // Ignore?
}
}
}
使用法：
new ProcessRunner().StartProcess("c:\\Windows\\system32\\calc.exe");
アンマネージコードを必要としないこの問題の解決策を探していました。また、Windowsフォームアプリケーションであるため、標準の入出力リダイレクトを使用することもできませんでした。
私の解決策は、親プロセスで名前付きパイプを作成してから、子プロセスを同じパイプに接続することでした。親プロセスが終了すると、パイプが破損し、子プロセスがこれを検出できます。
以下は、2つのコンソールアプリケーションを使用した例です。
親
private const string PipeName = "471450d6-70db-49dc-94af-09d3f3eba529";
public static void Main(string[] args)
{
Console.WriteLine("Main program running");
using (NamedPipeServerStream pipe = new NamedPipeServerStream(PipeName, PipeDirection.Out))
{
Process.Start("child.exe");
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
子
private const string PipeName = "471450d6-70db-49dc-94af-09d3f3eba529"; // same as parent
public static void Main(string[] args)
{
Console.WriteLine("Child process running");
using (NamedPipeClientStream pipe = new NamedPipeClientStream(".", PipeName, PipeDirection.In))
{
pipe.Connect();
pipe.BeginRead(new byte[1], 0, 1, PipeBrokenCallback, pipe);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
private static void PipeBrokenCallback(IAsyncResult ar)
{
// the pipe was closed (parent process died), so exit the child process too
try
{
NamedPipeClientStream pipe = (NamedPipeClientStream)ar.AsyncState;
pipe.EndRead(ar);
}
catch (IOException) { }
Environment.Exit(1);
}
event handlersを使用して、いくつかの終了シナリオでフックを作成します。
var process = Process.Start("program.exe");
AppDomain.CurrentDomain.DomainUnload += (s, e) => { process.Kill(); process.WaitForExit(); };
AppDomain.CurrentDomain.ProcessExit += (s, e) => { process.Kill(); process.WaitForExit(); };
AppDomain.CurrentDomain.UnhandledException += (s, e) => { process.Kill(); process.WaitForExit(); };
ちょうど私の2018バージョン。 Main（）メソッドとは別に使用します。
using System.Management;
using System.Diagnostics;
...
// Called when the Main Window is closed
protected override void OnClosed(EventArgs EventArgs)
{
string query = "Select * From Win32_Process Where ParentProcessId = " + Process.GetCurrentProcess().Id;
ManagementObjectSearcher searcher = new ManagementObjectSearcher(query);
ManagementObjectCollection processList = searcher.Get();
foreach (var obj in processList)
{
object data = obj.Properties["processid"].Value;
if (data != null)
{
// retrieve the process
var childId = Convert.ToInt32(data);
var childProcess = Process.GetProcessById(childId);
// ensure the current process is still live
if (childProcess != null) childProcess.Kill();
}
}
Environment.Exit(0);
}
次の2つのオプションがあります。
- 開始できる子プロセスが正確にわかっていて、メインプロセスからのみ開始されることが確実な場合は、名前で単純に検索して強制終了することを検討できます。
- すべてのプロセスを反復処理し、自分のプロセスを親として持つすべてのプロセスを強制終了します（最初に子プロセスを強制終了する必要があると思います）。 ここ は、親プロセスIDを取得する方法を説明しています。
双方向WCFパイプにより親プロセスと子プロセスが監視される子プロセス管理ライブラリを作成しました。子プロセスが終了するか、親プロセスが終了するかが通知されます。 VSデバッガーを開始された子プロセスに自動的にアタッチするデバッガーヘルパーもあります。
プロジェクトサイト：
http://www.crawler-lib.net/child-processes
NuGetパッケージ：
https://www.nuget.org/packages/ChildProcesseshttps://www.nuget.org/packages/ChildProcesses.VisualStudioDebug/
プロセスの開始後に行う方がよいjob.AddProcessを呼び出します。
prc.Start();
job.AddProcess(prc.Handle);
終了前にAddProcessを呼び出すと、子プロセスは強制終了されません。 （Windows 7 SP1）
private void KillProcess(Process proc)
{
var job = new Job();
job.AddProcess(proc.Handle);
job.Close();
}