C# ProcessPriorityClass类代码示例

 private bool CheckForNeedButton(ProcessPriorityClass priority)
 {
     if (priority == ProcessPriorityClass.Normal)
     {
         radioButton1.Checked = true;
         return true;
     }
     else if (priority == ProcessPriorityClass.AboveNormal)
     {
         radioButton2.Checked = true;
         return true;
     }
     else if (priority == ProcessPriorityClass.BelowNormal)
     {
         radioButton3.Checked = true;
         return true;
     }
     else if (priority == ProcessPriorityClass.High)
     {
         radioButton4.Checked = true;
         return true;
     }
     else if (priority == ProcessPriorityClass.Idle)
     {
         radioButton5.Checked = true;
         return true;
     }
     else if (priority == ProcessPriorityClass.RealTime)
     {
         radioButton6.Checked = true;
         return true;
     }
     return false;
 }

 public ConsoleProcess()
 {
     BufferSizeStdout = 4096;
     BufferSizeStderr = 4096;
     ModeStderr = CommunicationMode.Line;
     ModeStdout = CommunicationMode.Line;
     PriorityClass = ProcessPriorityClass.Normal;
 }

        public virtual void SetPriority(int processId, ProcessPriorityClass priority)
        {
            var process = Process.GetProcessById(processId);

            Logger.Info("Updating [{0}] process priority from {1} to {2}",
                        process.ProcessName,
                        process.PriorityClass,
                        priority);

            process.PriorityClass = priority;
        }

        public void Initialize()
        {
            this.CachedProcessPriorityClass = Process.GetCurrentProcess().PriorityClass;
            this.CachedThreadPriority = Thread.CurrentThread.Priority;
            
            Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.High;
            Thread.CurrentThread.Priority = ThreadPriority.Highest;

            this.IsCachedStatus = true;

            this.Time(1, () => { });
        }

        private void ChangePriority(ProcessPriorityClass priority)
        {
            cbxPriority.SelectedValue = priority;

            for (var i = 0; i < tsmiPriority.DropDownItems.Count; i++)
            {
                var item = (ToolStripMenuItem)tsmiPriority.DropDownItems[i];
                item.Checked = (int)item.Tag == (int)priority;
            }

            processor.Priority = priority;
        }

#pragma warning disable 0618
		/// <summary>
		/// Initializes a new instance of the <see cref="HighPerformance"/> class.
		/// </summary>
		internal HighPerformance() {
			////if (!WaitForQuietCpu()) {
			////    Assert.Inconclusive("Timed out waiting for a quiet CPU in which to perform perf tests.");
			////}

			this.originalLoggerThreshold = LogManager.GetLoggerRepository().Threshold;
			LogManager.GetLoggerRepository().Threshold = LogManager.GetLoggerRepository().LevelMap["OFF"];
			this.powerSetting = new PowerManagment.PowerSetting(PowerManagment.PowerProfiles.HighPerformance);
			this.originalProcessPriority = Process.GetCurrentProcess().PriorityClass;
			Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.High;
			Thread.CurrentThread.Priority = ThreadPriority.Highest;
			SpinCpu();
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="ProcessInfo"/> class.
 /// </summary>
 /// <param name="filename">The filename.</param>
 /// <param name="arguments">The arguments.</param>
 /// <param name="workingDirectory">The working directory.</param>
 /// <param name="priority">The priority.</param>
 /// <param name="successExitCodes">The success exit codes.</param>
 public ProcessInfo(string filename, SecureArguments arguments, string workingDirectory, ProcessPriorityClass priority, int[] successExitCodes)
 {
     this.arguments = arguments;
     this.priority = priority;
     startInfo.FileName = filename.StripQuotes();
     startInfo.Arguments = arguments == null ? null : arguments.ToString(SecureDataMode.Private);
     startInfo.WorkingDirectory = workingDirectory.StripQuotes();
     startInfo.UseShellExecute = false;
     startInfo.CreateNoWindow = true;
     startInfo.RedirectStandardOutput = true;
     startInfo.RedirectStandardError = true;
     startInfo.RedirectStandardInput = false;
     this.successExitCodes = successExitCodes ?? new[] { 0 };
 }

 /// <summary>
 /// Executes the <paramref name="executable"/> and waits a maximum time of <paramref name="maxWaitMs"/> for completion. If the process doesn't end in 
 /// this time, it gets aborted. This method tries to impersonate the interactive user and run the process under its identity.
 /// </summary>
 /// <param name="executable">Program to execute</param>
 /// <param name="arguments">Program arguments</param>
 /// <param name="priorityClass">Process priority</param>
 /// <param name="maxWaitMs">Maximum time to wait for completion</param>
 /// <returns><c>true</c> if process was executed and finished correctly</returns>
 public static bool TryExecute_Impersonated(string executable, string arguments, ProcessPriorityClass priorityClass = ProcessPriorityClass.Normal, int maxWaitMs = INFINITE)
 {
   IntPtr userToken;
   if (!ImpersonationHelper.GetTokenByProcess(out userToken, true))
     return false;
   try
   {
     string unused;
     return TryExecute_Impersonated(executable, arguments, userToken, false, out unused, priorityClass, maxWaitMs);
   }
   finally
   {
     ImpersonationHelper.SafeCloseHandle(userToken);
   }
 }

 /// <summary>
 /// Executes the <paramref name="executable"/> and waits a maximum time of <paramref name="maxWaitMs"/> for completion and returns the contents of
 /// <see cref="Process.StandardOutput"/>. If the process doesn't end in this time, it gets aborted.
 /// </summary>
 /// <param name="executable">Program to execute</param>
 /// <param name="arguments">Program arguments</param>
 /// <param name="result">Returns the contents of standard output</param>
 /// <param name="priorityClass">Process priority</param>
 /// <param name="maxWaitMs">Maximum time to wait for completion</param>
 /// <returns></returns>
 public static bool TryExecuteReadString(string executable, string arguments, out string result, ProcessPriorityClass priorityClass = ProcessPriorityClass.Normal, int maxWaitMs = 1000)
 {
   using (System.Diagnostics.Process process = new System.Diagnostics.Process { StartInfo = new ProcessStartInfo(executable, arguments) { UseShellExecute = false, CreateNoWindow = true, RedirectStandardOutput = true } })
   {
     process.Start();
     process.PriorityClass = priorityClass;
     using (process.StandardOutput)
     {
       result = process.StandardOutput.ReadToEnd();
       if (process.WaitForExit(maxWaitMs))
         return process.ExitCode == 0;
     }
     if (!process.HasExited)
       process.Kill();
   }
   return false;
 }

        public ClientConnection(string hostName, string ipAddress, int instance, ProcessPriorityClass priority, int bitSize)
        {
            IsOnline = true;
            Jobs = new List<Job>();
            PriorityJobs = new List<Job>();
            CurrentJob = "";
            ActiveHours = "YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY";
            Id = (_nextClientId++);
            HostName = hostName;
            IPAddress = ipAddress;
            Instance = instance;
            Priority = priority;
            BitSize = bitSize;
            _lastCall.Reset();
            _lastCall.Start();

            RestoreSettings();
        }

        public void Run(ProcessEx process, ProcessPriorityClass priority)
        {
            if (this.Status.InUse)
            throw new InvalidOperationException("Current core is running another process");

              if (process == null)
            throw new ArgumentNullException("Process can not be null");

              this.Process = process;
              this.Process.ExecutingCore = this;

              //bind event
              this.Process.Exited += Process_Exited;

              this.Process.Start();
              this.Process.Status = ProcessExecutionStatus.Running;
              this.Process.PriorityClass = priority;
              this.Status.InUse = true;

              //TODO set affinity
              this.Process.ProcessorAffinity = (IntPtr) (int) Math.Pow(2, this.Status.Index);
        }

        public void RegistSchedule(string serviceName,ProcessPriorityClass Priority,string FilePath,string args)
        {
            using (TaskService task= new TaskService())
            {
                string SchedulerName= "GISHitpanDBManager"+Guid.NewGuid().ToString();
                using(TaskDefinition def = task.NewTask())
                {
                    //일반
                    def.Principal.DisplayName = serviceName;
                    def.Principal.UserId=string.Format("{0}\\{1}",Environment.UserDomainName,Environment.UserName);
                    def.Principal.LogonType=TaskLogonType.InteractiveToken;
                    def.Principal.RunLevel=TaskRunLevel.Highest;
                    def.Triggers.Add( new LogonTrigger());
                    //조건
                    def.Settings.MultipleInstances=TaskInstancesPolicy.IgnoreNew;
                    def.Settings.DisallowStartIfOnBatteries=false;
                    def.Settings.StopIfGoingOnBatteries=false;
                    def.Settings.AllowHardTerminate=false;
                    def.Settings.StartWhenAvailable=true;
                    def.Settings.RunOnlyIfNetworkAvailable=false;
                    def.Settings.IdleSettings.StopOnIdleEnd=false;
                    def.Settings.IdleSettings.RestartOnIdle=false;
                    //설정
                    def.Settings.AllowDemandStart=false;
                    def.Settings.Enabled=true;
                    def.Settings.Hidden=false;
                    def.Settings.RunOnlyIfIdle=false;
                    def.Settings.ExecutionTimeLimit=TimeSpan.Zero;
                    def.Settings.Priority = Priority;
                    //동작
                    def.Actions.Add(FilePath, args);
                    //등록
                    task.RootFolder.RegisterTaskDefinition(SchedulerName,def);
                }

            }
        }

 /// <summary>
 /// Queues the process.
 /// </summary>
 /// <param name="process">The process to enqueue.</param>
 /// <param name="prc">process priority.</param>
 public void QueueProcess(ProcessEx process, ProcessPriorityClass prc)
 {
     lock (_queueLock)
       {
     this._processQueue.Enqueue(new KeyValuePair<ProcessEx, ProcessPriorityClass>(process, prc));
     process.Status = ProcessExecutionStatus.Queued;
       }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ProcessInfo" /> class.	
 /// </summary>
 /// <param name="filename">The filename.</param>
 /// <param name="arguments">The arguments.</param>
 /// <param name="workingDirectory">The working directory.</param>
 /// <param name="priority">The priority.</param>
 /// <remarks></remarks>
 public ProcessInfo(string filename, PrivateArguments arguments, string workingDirectory, ProcessPriorityClass priority) :
     this(filename, arguments, workingDirectory, priority, null){}

 private void SetProcessPriority(ProcessPriorityClass priority)
 {
     try
     {
         using (var phandle = new ProcessHandle(processSelectedPid, ProcessAccess.SetInformation))
             phandle.SetPriorityClass(priority);
     }
     catch (Exception ex)
     {
         PhUtils.ShowException("Unable to set process priority", ex);
     }
 }