public JobObject Build()
{
var jobObject = new JobObject();
var lim = new JobObjectExtendedLimitInformation
{
BasicLimitInformation = new JobObjectBasicLimitInformation
{
LimitFlags = LimitFlag,
ActiveProcessLimit = ProcessCounts,
PerProcessUserTimeLimit = UserTimeLimit,
},
ProcessMemoryLimit = new UIntPtr(ProcessMemoryLimit),
};
jobObject.SetExtendedLimit(ref lim);
jobObject.SetUIRestrictions(LimitFunction);
return(jobObject);
}
public unsafe Process Build(JobObject jobObject = null)
{
var jo = jobObject ?? hJobObject;
var flg = flags;
if (jo != null)
{
flg |= CreateProcessFlags.CreateSuspended;
}
var si = new StartupInfo
{
cb = Marshal.SizeOf <StartupInfo>(),
dwFlags = stf
};
var pi = new ProcessInformation();
Pipe stdin = null, stdout = null, stderr = null;
// Set the redirect of standard io handles
if ((stf & StartFlag.UseStdHandles) != 0)
{
SafeFileHandle useIn, useOut, useErr;
if (this.useIn)
{
stdin = new Pipe(true);
useIn = stdin.ChildrenHandle;
}
else
{
useIn = Kernel32.GetStdHandle(StdHandle.Input);
}
if (this.useOut)
{
stdout = new Pipe(false);
useOut = stdout.ChildrenHandle;
}
else
{
useOut = Kernel32.GetStdHandle(StdHandle.Output);
}
if (this.useErr)
{
stderr = new Pipe(false);
useErr = stderr.ChildrenHandle;
}
else
{
useErr = Kernel32.GetStdHandle(StdHandle.Error);
}
si.hStdInput = useIn.DangerousGetHandle();
si.hStdOutput = useOut.DangerousGetHandle();
si.hStdError = useErr.DangerousGetHandle();
}
SecurityAttributes sc = new SecurityAttributes();
fixed(char *envPtr = env)
{
var res = Kernel32.CreateProcessW(fileName, args,
&sc, &sc, true, flg,
IntPtr.Zero, workDir, ref si, ref pi);
if (!res)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}
var proc = new SafeProcessHandle(pi.hProcess, true);
if (jo != null)
{
jo.AssignProcess(proc);
Kernel32.ResumeThread(pi.hThread);
}
Kernel32.CloseHandle(pi.hThread);
return(new Process(proc, stdin, stdout, stderr, encoding));
}
public ProcessBuilder AssignTo(JobObject jobObject)
{
hJobObject = jobObject;
return(this);
}
