class JobObjectProcess

{

    protected Process _process;

    protected IntPtr _jobHandle;

    public JobObjectProcess(ProcessStartInfo startInfo)

    {

        _process = new Process();

        _process.StartInfo = startInfo;

        CreateJobObject();

    }

    private void CreateJobObject()

    {

        win32.SECURITY_ATTRIBUTES SA = new win32.SECURITY_ATTRIBUTES();

        SA.nLength = 12;

        SA.SecurityDescriptor = IntPtr.Zero;

        SA.bInheritHandle = true;

        _jobHandle = win32.CreateJobObject(ref SA, "");

    }

    public bool Start()

    {

        bool started = _process.Start();

        if (started)

        {

            bool success = win32.AssignProcessToJobObject(_jobHandle, _process.Handle);

            if (!success)

            {

                string error = new Win32Exception(Marshal.GetLastWin32Error()).Message;

                throw new ApplicationException(error);

            }

        }

        return started;

    }

    public void Kill()

    {

        bool success = win32.TerminateJobObject(_jobHandle, 0);

        if (!success)

        {

            string error = new Win32Exception(Marshal.GetLastWin32Error()).Message;

            throw new ApplicationException(error);

        }

        if (_jobHandle != IntPtr.Zero)

        {

            if (0 == win32.CloseHandle(_jobHandle))

            {

                string error = new Win32Exception(Marshal.GetLastWin32Error()).Message;

                throw new ApplicationException(error);

            }

            _jobHandle = IntPtr.Zero;

        }

    }

}

class JobObjectProcess

{

    private IntPtr _jobHandle;

    public JobObjectProcess()

    {

    }

    public bool Start(string commandLinePath)

    {

        IntPtr Token = new IntPtr(0);

        IntPtr DupedToken = new IntPtr(0);

        bool ret;

        SECURITY_ATTRIBUTES sa = new SECURITY_ATTRIBUTES();

        sa.bInheritHandle = false;

        sa.Length = Marshal.SizeOf(sa);

        sa.lpSecurityDescriptor = (IntPtr)0;

        Token = WindowsIdentity.GetCurrent().Token;

        const uint GENERIC_ALL = 0x10000000;

        const int SecurityImpersonation = 2;

        const int TokenType = 1;

        ret = DuplicateTokenEx(Token, GENERIC_ALL, ref sa, SecurityImpersonation, TokenType, ref DupedToken);

        STARTUPINFO si = new STARTUPINFO();

        si.cb = Marshal.SizeOf(si);

        si.lpDesktop = "";

        PROCESS_INFORMATION pi = new PROCESS_INFORMATION();

        const int CREATE_SUSPENDED = 0x00000004;

        ret = CreateProcessAsUser(DupedToken, null, commandLinePath, ref sa, ref sa, false, CREATE_SUSPENDED, (IntPtr)0, "c:/", ref si, out pi);

        SECURITY_ATTRIBUTES saJob = new SECURITY_ATTRIBUTES();

        saJob.Length = 12;

        saJob.lpSecurityDescriptor = IntPtr.Zero;

        saJob.bInheritHandle = true;

        _jobHandle = CreateJobObject(ref saJob, "");

        bool success = AssignProcessToJobObject(_jobHandle, pi.hProcess);

        int nSuspendCount = ResumeThread(pi.hThread);

        CloseHandle(pi.hProcess);

        CloseHandle(pi.hThread);

        CloseHandle(DupedToken);

        return true;

    }

    public bool Kill()

    {

        bool success = TerminateJobObject(_jobHandle, 0);

        CloseHandle(_jobHandle);

        return success;

    }

    [StructLayout(LayoutKind.Sequential)]

    public struct STARTUPINFO

    {

        public int cb;

        public String lpReserved;

        public String lpDesktop;

        public String lpTitle;

        public uint dwX;

        public uint dwY;

        public uint dwXSize;

        public uint dwYSize;

        public uint dwXCountChars;

        public uint dwYCountChars;

        public uint dwFillAttribute;

        public uint dwFlags;

        public short wShowWindow;

        public short cbReserved2;

        public IntPtr lpReserved2;

        public IntPtr hStdInput;

        public IntPtr hStdOutput;

        public IntPtr hStdError;

    }

    [StructLayout(LayoutKind.Sequential)]

    public struct PROCESS_INFORMATION

    {

        public IntPtr hProcess;

        public IntPtr hThread;

        public uint dwProcessId;

        public uint dwThreadId;

    }

    [StructLayout(LayoutKind.Sequential)]

    public struct SECURITY_ATTRIBUTES

    {

        public int Length;

        public IntPtr lpSecurityDescriptor;

        public bool bInheritHandle;

    }

    [DllImport("kernel32.dll", EntryPoint = "CloseHandle", SetLastError = true, CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]

    public extern static bool CloseHandle(IntPtr handle);

    [DllImport("advapi32.dll", EntryPoint = "CreateProcessAsUser", SetLastError = true, CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

    public extern static bool CreateProcessAsUser(IntPtr hToken, String lpApplicationName, String lpCommandLine, ref SECURITY_ATTRIBUTES lpProcessAttributes,

        ref SECURITY_ATTRIBUTES lpThreadAttributes, bool bInheritHandle, int dwCreationFlags, IntPtr lpEnvironment,

        String lpCurrentDirectory, ref STARTUPINFO lpStartupInfo, out PROCESS_INFORMATION lpProcessInformation);

    [DllImport("advapi32.dll", EntryPoint = "DuplicateTokenEx")]

    public extern static bool DuplicateTokenEx(IntPtr ExistingTokenHandle, uint dwDesiredAccess,

        ref SECURITY_ATTRIBUTES lpThreadAttributes, int TokenType,

        int ImpersonationLevel, ref IntPtr DuplicateTokenHandle);

    [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]

    public static extern IntPtr CreateJobObject(ref SECURITY_ATTRIBUTES JobAttributes,

        [MarshalAs(UnmanagedType.LPTStr)]string strName);

    [DllImport("kernel32.dll", SetLastError = true)]

    public static extern bool AssignProcessToJobObject(IntPtr hJob, IntPtr hProcess);

    [DllImport("kernel32.dll", SetLastError = true)]

    public static extern bool TerminateJobObject(IntPtr hJob, uint exitCode);

    [DllImport("kernel32.dll", SetLastError = true)]

    public static extern int ResumeThread(IntPtr hThread);

}