Wie kann ich sicherstellen, dass Kinderprozesse enden, wenn der übergeordnete Prozess in C#endet?

Die Auswirkung der Beendigung eines übergeordneten Prozesses auf die Beendigung eines untergeordneten Prozesses in C#

Bei der Softwareentwicklung ist der Umgang mit dem Verhalten des untergeordneten Prozesses bei Beendigung des übergeordneten Prozesses von entscheidender Bedeutung für die Aufrechterhaltung der Systemstabilität. Wenn mehrere untergeordnete Prozesse von einem übergeordneten Prozess erzeugt werden, muss sichergestellt werden, dass sie mit dem übergeordneten Prozess beendet werden. In diesem Artikel wird ein häufiges Problem besprochen: Mit der Klasse System.Diagnostics.Process erzeugte untergeordnete Prozesse bleiben auch dann bestehen, wenn die Hauptanwendung abstürzt oder über den Task-Manager zwangsweise beendet wird.

Jobobjekt: Lösung für die Eltern-Kind-Prozesshierarchie

Um Abhängigkeiten zwischen untergeordneten Prozessen und übergeordneten Prozessen herzustellen, kann eine Funktion namens „Job Objects“ verwendet werden. Jobobjekte ermöglichen die Erstellung hierarchischer Beziehungen zwischen Prozessen, wobei die Beendigung eines übergeordneten Jobobjekts auch die Beendigung aller zugehörigen untergeordneten Prozesse zur Folge hat.

Der folgende Code zeigt, wie ein Jobobjekt verwendet wird, um Abhängigkeiten von untergeordneten Prozessen zu verwalten:

<code class="language-csharp">using System;
using System.Runtime.InteropServices;
using System.Diagnostics;

public class Job : IDisposable
{
    [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
    static extern IntPtr CreateJobObject(IntPtr 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 _handle;
    private bool _disposed = false;

    public Job()
    {
        _handle = CreateJobObject(IntPtr.Zero, null);

        JOBOBJECT_BASIC_LIMIT_INFORMATION info = new JOBOBJECT_BASIC_LIMIT_INFORMATION();
        info.LimitFlags = 0x2000; // JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE

        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(_handle, JobObjectInfoType.ExtendedLimitInformation, extendedInfoPtr, (uint)length))
            throw new Exception($"无法设置信息。错误：{Marshal.GetLastWin32Error()}");

        Marshal.FreeHGlobal(extendedInfoPtr);
    }


    public void AddProcess(Process process)
    {
        if (!AssignProcessToJobObject(_handle, process.Handle))
            throw new Exception($"无法将进程分配到作业对象。错误：{Marshal.GetLastWin32Error()}");
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed)
            return;

        if (disposing) { }

        Close();
        _disposed = true;
    }

    public void Close()
    {
        if (_handle != IntPtr.Zero)
        {
            Win32.CloseHandle(_handle);
            _handle = IntPtr.Zero;
        }
    }
}

internal static class Win32
{
    [DllImport("kernel32.dll")]
    internal static extern bool CloseHandle(IntPtr hObject);
}

//  必要的结构体定义  (根据需要补充完整)
enum JobObjectInfoType
{
    ExtendedLimitInformation = 9
}

[StructLayout(LayoutKind.Sequential)]
internal struct IO_COUNTERS
{
    public UInt64 ReadOperationCount;
    public UInt64 WriteOperationCount;
    public UInt64 OtherOperationCount;
    public UInt64 ReadTransferCount;
    public UInt64 WriteTransferCount;
    public UInt64 OtherTransferCount;
}

[StructLayout(LayoutKind.Sequential)]
internal struct JOBOBJECT_BASIC_LIMIT_INFORMATION
{
    public Int64 PerProcessUserTimeLimit;
    public Int64 PerJobUserTimeLimit;
    public UInt32 LimitFlags;
    public UIntPtr MinimumWorkingSetSize;
    public UIntPtr MaximumWorkingSetSize;
    public UInt32 ActiveProcessLimit;
    public UInt32 Affinity;
    public UInt32 PriorityClass;
    public UInt32 SchedulingClass;
}

[StructLayout(LayoutKind.Sequential)]
internal struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION
{
    public JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
    public IO_COUNTERS IoInfo;
    public UInt64 ProcessMemoryLimit;
    public UInt64 JobMemoryLimit;
    public UInt64 PeakProcessMemoryUsed;
    public UInt64 PeakJobMemoryUsed;
}</code>

Nachdem Sie den untergeordneten Prozess erstellt haben, rufen Sie die Methode AddProcess() auf, um ihn mit dem eingerichteten Jobobjekt zu verknüpfen. Beachten Sie, dass dem Code die notwendige Strukturdefinition und Implementierung der IDisposable-Schnittstelle sowie die korrekte Freigabe von Ressourcen hinzugefügt wurden.

Das obige ist der detaillierte Inhalt vonWie kann ich sicherstellen, dass Kinderprozesse enden, wenn der übergeordnete Prozess in C#endet?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!