问如何以编程方式设置SeCreateGlobalPrivilege？

EN

public class FileView
{
    private readonly AutoResetEvent _run = new AutoResetEvent(false);
    private readonly AutoResetEvent _update = new AutoResetEvent(false);

    private ILog logger = LogManager.GetLogger("weldR");
    private bool IsDisposed { get; set; }

    private byte[] Data { get; set; }

    private string MapName { get; set; }

    private string MutexName { get; set; }

    private MemoryMappedFileSecurity Security { get; set; }

    public FileView(string url)
    {
        if (url.StartsWith("/"))
        {
            url = url.Substring(1);
        }
        MapName = string.Format("Global\\{0}",String.Concat("pipe://", url));
        MutexName = string.Format("Global\\{0}", url.GetHashCode().ToString("x"));
        Security = new MemoryMappedFileSecurity();
        Security.AddAccessRule(new System.Security.AccessControl.AccessRule<MemoryMappedFileRights>("everyone", 
            MemoryMappedFileRights.FullControl, System.Security.AccessControl.AccessControlType.Allow));

        Task.Factory.StartNew(Run);
    }

    void Run()
    {
        while (!IsDisposed)
        {
            if(Data != null)
            {
                Process process = Process.GetCurrentProcess();
                using (new PrivilegeEnabler(process, Privilege.CreateGlobal))
                {
                    var mutex = new Mutex(true, MutexName);

                    using (var mmf = MemoryMappedFile.CreateNew(MapName, Data.Length + 8,
                        MemoryMappedFileAccess.ReadWriteExecute, MemoryMappedFileOptions.None, Security, HandleInheritability.Inheritable))
                    {
                        using (var viewAccessor = mmf.CreateViewAccessor())
                        {
                            try
                            {
                                var size = Data.Length.Bytes();
                                viewAccessor.WriteArray(0, size, 0, size.Length);
                                viewAccessor.WriteArray(size.Length + 1, Data, 0, Data.Length);
                            }
                            catch (Exception e)
                            {
                                logger.ErrorFormat(e.ToString());
                            }
                        }
                        mutex.ReleaseMutex();

                        _update.Set();

                        _run.WaitOne();

                        mutex.WaitOne();
                    }     
                }
            }
            else
            {
                _run.WaitOne();
            }
        }
    }

    public void Update(byte[] data)
    { 
        Data = data;
        _run.Set();
        _update.WaitOne();
    }

    public void Dispose()
    { 
        IsDisposed = true;
        _run.Set();
        _update.Set();
    }
}
private static Action<OwinRequest, OwinResponse> Serve(string path)
    {
        return (request, response) =>
            {

                //var pipename = String.Concat("pipe://", path);
               // var pipemutex = path.GetHashCode().ToString("x");

                var pipename = string.Format("Global\\{0}", String.Concat("pipe://", path));
                var pipemutex = string.Format("Global\\{0}", path.GetHashCode().ToString("x"));

                using (var mmf = MemoryMappedFile.OpenExisting(pipename))
                {
                    using (var mutex = Mutex.OpenExisting(pipemutex))
                    {
                        try
                        {
                            mutex.WaitOne();
                            using (var accessor = mmf.CreateViewAccessor())
                            {
                                var offset = 0;
                                var fileLength = new byte[4];
                                accessor.ReadArray(offset, fileLength, 0, fileLength.Length);
                                offset += fileLength.Length;
                                var size = fileLength.Int32();
                                var buff = new byte[size];
                                accessor.ReadArray(offset, buff, 0, buff.Length);

                                var lastWriteTimeUtc = new DateTime();
                                var etag = string.Concat("\"", lastWriteTimeUtc.Ticks.ToString("x"), "\"");
                                var lastModified = lastWriteTimeUtc.ToString("R");
                                if ("HEAD".Equals(request.Method, StringComparison.OrdinalIgnoreCase))
                                    return;

                                //if (CacheHelpers.ReturnNotModified(etag, lastWriteTimeUtc, context))
                                //{
                                //    mutex.ReleaseMutex();
                                //    return TaskHelpers.Completed();
                                //}
                                response.AddHeader("ETag", etag);
                                response.AddHeader("Last-Modified", lastModified);
                                response.AddHeader("Content-Type", Mime.MimeTypeFromExtension(path, "text/plain"));
                                response.AddHeader("Content-Length", size.ToString(CultureInfo.InvariantCulture));

                                response.Body.Write(buff, 0, buff.Length);
                            }
                        }
                        finally
                        {
                            mutex.ReleaseMutex();
                        }
                    }
                }
            };
    }