Comment utiliser P/Invoke pour créer et gérer des objets de tâche en C# afin de garantir la fin du processus ?

Exemple d'implémentation de CreateJobObject et SetInformationJobObject à l'aide de P/Invoke

Cet exemple montre comment créer un objet de travail (CreateJobObject) et définir son élément de base limiter les informations (SetInformationJobObject) pour garantir que les processus associés au travail se terminent lorsque le travail est fermé.

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace JobObjectPInvoke
{
    class Program
    {
        const int JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x2000;

        [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, UInt32 cbJobObjectInfoLength);

        [DllImport("kernel32.dll", SetLastError = true)]
        static extern bool CloseHandle(IntPtr hObject);

        static void Main()
        {
            // Get a handle to the current process.
            IntPtr currentProcessHandle = Process.GetCurrentProcess().Handle;

            // Create a job object.
            IntPtr jobObjectHandle = CreateJobObject(IntPtr.Zero, null);
            if (jobObjectHandle == IntPtr.Zero)
            {
                throw new Exception($"Failed to create job object: {Marshal.GetLastWin32Error()}");
            }

            // Set the limit information for the job object.
            JOBOBJECT_BASIC_LIMIT_INFORMATION jobLimitInfo = new JOBOBJECT_BASIC_LIMIT_INFORMATION
            {
                LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
            };

            int sizeOfJobLimitInfo = Marshal.SizeOf(jobLimitInfo);
            IntPtr ptrJobLimitInfo = Marshal.AllocHGlobal(sizeOfJobLimitInfo);
            Marshal.StructureToPtr(jobLimitInfo, ptrJobLimitInfo, false);

            if (!SetInformationJobObject(jobObjectHandle, JobObjectInfoType.BasicLimitInformation, ptrJobLimitInfo, (uint)sizeOfJobLimitInfo))
            {
                throw new Exception($"Failed to set job limit information: {Marshal.GetLastWin32Error()}");
            }

            // Add the current process to the job object.
            if (!AssignProcessToJobObject(jobObjectHandle, currentProcessHandle))
            {
                throw new Exception($"Failed to add process to job object: {Marshal.GetLastWin32Error()}");
            }

            // Sleep for 10 seconds.
            System.Threading.Thread.Sleep(10000);

            // Close the job object.
            CloseHandle(jobObjectHandle);

            // The current process will terminate when the job object is closed. You can use this example to create a sandbox environment for your processes.
        }

        #region Helper Classes

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

        public enum JobObjectInfoType
        {
            AssociateCompletionPortInformation = 7,
            BasicLimitInformation = 2,
            BasicUIRestrictions = 4,
            EndOfJobTimeInformation = 6,
            ExtendedLimitInformation = 9,
            SecurityLimitInformation = 5
        }

        #endregion
    }
}

Cet exemple développé illustre une implémentation complète de création d'un objet de travail, de définition de ses informations de limite de base et d'ajout d'un processus à l'objet de travail. L'indicateur JOBOBJECT_LIMIT_KILL_ON_JOB_CLOSE garantit que tous les processus associés au travail seront terminés lorsque l'objet de travail sera fermé, garantissant ainsi que toutes les ressources utilisées par les processus sont correctement nettoyées.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!