C# WorkItemPriority类代码示例

 /// <summary>
 ///   Create a new work item
 /// </summary>
 /// <param name = "wigStartInfo">Work item group start information</param>
 /// <param name = "callback">A callback to execute</param>
 /// <param name = "workItemPriority">The priority of the work item</param>
 /// <returns>Returns a work item</returns>
 public static WorkItem CreateWorkItem(
     IWorkItemsGroup workItemsGroup,
     WIGStartInfo wigStartInfo,
     WorkItemCallback callback,
     WorkItemPriority workItemPriority)
 {
     return CreateWorkItem(workItemsGroup, wigStartInfo, callback, null, workItemPriority);
 }

 // Creates a new instance with the specified degree of parallelism. 
 public LimitedConcurrencyLevelTaskScheduler(int maxDegreeOfParallelism, WorkItemPriority priority, bool fDisableInlining = false)
 {
     if (maxDegreeOfParallelism < 1)
     {
         throw new ArgumentOutOfRangeException("maxDegreeOfParallelism");
     }
     this._maxDegreeOfParallelism = maxDegreeOfParallelism;
     this._workItemPriority = priority;
     this._fDisableInlining = fDisableInlining;
 }

 public WIGStartInfo(WIGStartInfo wigStartInfo)
 {
     _useCallerCallContext = wigStartInfo.UseCallerCallContext;
     _useCallerHttpContext = wigStartInfo.UseCallerHttpContext;
     _disposeOfStateObjects = wigStartInfo.DisposeOfStateObjects;
     _callToPostExecute = wigStartInfo.CallToPostExecute;
     _postExecuteWorkItemCallback = wigStartInfo.PostExecuteWorkItemCallback;
     _workItemPriority = wigStartInfo.WorkItemPriority;
     _startSuspended = wigStartInfo.StartSuspended;
     _fillStateWithArgs = wigStartInfo.FillStateWithArgs;
 }

 // Token: 0x06001837 RID: 6199
 // RVA: 0x00074E5C File Offset: 0x0007305C
 public WIGStartInfo(WIGStartInfo wigstartInfo_0)
 {
     this._useCallerCallContext = wigstartInfo_0.UseCallerCallContext;
     this._useCallerHttpContext = wigstartInfo_0.UseCallerHttpContext;
     this._disposeOfStateObjects = wigstartInfo_0.DisposeOfStateObjects;
     this._callToPostExecute = wigstartInfo_0.CallToPostExecute;
     this._postExecuteWorkItemCallback = wigstartInfo_0.PostExecuteWorkItemCallback;
     this._workItemPriority = wigstartInfo_0.WorkItemPriority;
     this._startSuspended = wigstartInfo_0.StartSuspended;
     this._fillStateWithArgs = wigstartInfo_0.FillStateWithArgs;
 }

 // Token: 0x0600185F RID: 6239
 // RVA: 0x00075274 File Offset: 0x00073474
 public static WorkItem CreateWorkItem(IWorkItemsGroup iworkItemsGroup_0, WIGStartInfo wigstartInfo_0, WorkItemCallback workItemCallback_0, object object_0, WorkItemPriority workItemPriority_0)
 {
     WorkItemFactory.ValidateCallback(workItemCallback_0);
     return new WorkItem(iworkItemsGroup_0, new WorkItemInfo
     {
         UseCallerCallContext = wigstartInfo_0.UseCallerCallContext,
         UseCallerHttpContext = wigstartInfo_0.UseCallerHttpContext,
         PostExecuteWorkItemCallback = wigstartInfo_0.PostExecuteWorkItemCallback,
         CallToPostExecute = wigstartInfo_0.CallToPostExecute,
         DisposeOfStateObjects = wigstartInfo_0.DisposeOfStateObjects,
         WorkItemPriority = workItemPriority_0
     }, workItemCallback_0, object_0);
 }

 private void EnqueueWorkItems(ref int startIndex, int count, string text, Color color, WorkItemPriority priority, IWorkItemsGroup wig, int sleepDuration)
 {
     for (int i = 0; i < count; ++i, ++startIndex)
     {
         wig.QueueWorkItem(
             DoNothing,
             new WorkItemState(new QueueUsageControl.QueueUsageEntry(string.Format("{0}{1} ({2})", text, startIndex, priority.ToString().Substring(0,2 )), color), sleepDuration),
             priority);
     }
     _workItemsGenerated += count;
 }

		public static IAsyncAction RunAsync (WorkItemHandler handler, WorkItemPriority priority)
		{
			return RunAsync (handler);
		}

		    public PriorityItem(WorkItemPriority workItemPriority)
			{
				WorkItemPriority = workItemPriority;
			}

 /// <summary>
 /// Queue a work item
 /// </summary>
 /// <param name="callback">A callback to execute</param>
 /// <param name="state">
 /// The context object of the work item. Used for passing arguments to the work item. 
 /// </param>
 /// <param name="postExecuteWorkItemCallback">
 /// A delegate to call after the callback completion
 /// </param>
 /// <param name="callToPostExecute">Indicates on which cases to call to the post execute callback</param>
 /// <param name="workItemPriority">The work item priority</param>
 /// <returns>Returns a work item result</returns>
 public IWorkItemResult QueueWorkItem(
     WorkItemCallback callback,
     object state,
     PostExecuteWorkItemCallback postExecuteWorkItemCallback,
     CallToPostExecute callToPostExecute,
     WorkItemPriority workItemPriority)
 {
     WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, callback, state,
                                                        postExecuteWorkItemCallback, callToPostExecute,
                                                        workItemPriority);
     EnqueueToSTPNextWorkItem(workItem);
     return workItem.GetWorkItemResult();
 }

		/// <summary>
		/// Create a new work item
		/// </summary>
		/// <param name="workItemsGroup">The work items group</param>
		/// <param name="wigStartInfo">Work item group start information</param>
		/// <param name="callback">A callback to execute</param>
		/// <param name="state">
		/// The context object of the work item. Used for passing arguments to the work item. 
		/// </param>
		/// <param name="workItemPriority">The work item priority</param>
		/// <returns>Returns a work item</returns>
		public static WorkItem CreateWorkItem(
			IWorkItemsGroup workItemsGroup,
			WIGStartInfo wigStartInfo,
			WorkItemCallback callback, 
			object state, 
			WorkItemPriority workItemPriority)
		{
			ValidateCallback(callback);

			WorkItemInfo workItemInfo = new WorkItemInfo();
			workItemInfo.UseCallerCallContext = wigStartInfo.UseCallerCallContext;
			workItemInfo.UseCallerHttpContext = wigStartInfo.UseCallerHttpContext;
			workItemInfo.PostExecuteWorkItemCallback = wigStartInfo.PostExecuteWorkItemCallback;
			workItemInfo.CallToPostExecute = wigStartInfo.CallToPostExecute;
			workItemInfo.DisposeOfStateObjects = wigStartInfo.DisposeOfStateObjects;
			workItemInfo.WorkItemPriority = workItemPriority;

			WorkItem workItem = new WorkItem(
				workItemsGroup,
				workItemInfo,
				callback, 
				state);

			return workItem;
		}

        /// <summary>
        /// Add a file to download to the queue
        /// You have to subscribe to the <see cref="DownloadProgressNotification"/> event to get notified when the download is finished.
        /// </summary>
        /// <param name="uri">File to download</param>
        /// <param name="localFile">Local path to download to</param>
        /// <param name="identifier">Arbitrary identifier</param>
        /// <param name="overwriteExistingFile">Overwrite an already existing file</param>
        /// <param name="retries">Number of times to retry the download until we fail</param>
        /// <param name="priority">Priority for the WorkItem</param>
        public void AddDownload(Uri uri, FileInfo localFile, object identifier, bool overwriteExistingFile, int retries, WorkItemPriority priority)
        {
            var fileDownloadInfo = new FileDownloadInfo{ Url = uri, Identifier = identifier, LocalFile = localFile, Priority = priority, Retries = retries, OverwriteExistingFile = overwriteExistingFile };

            lock (downloadThreadPoolLockObject)
            {
                downloadThreadPool.QueueWorkItem(this.DoWork, fileDownloadInfo, priority);
            }
        }

 /// <summary>
 /// Queue a work item
 /// </summary>
 /// <param name="callback">A callback to execute</param>
 /// <param name="workItemPriority">The priority of the work item</param>
 /// <returns>Returns a work item result</returns>
 public IWorkItemResult QueueWorkItem(WorkItemCallback callback, WorkItemPriority workItemPriority)
 {
     ValidateNotDisposed();
     ValidateCallback(callback);
     WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _stpStartInfo, callback, workItemPriority);
     Enqueue(workItem);
     return workItem.GetWorkItemResult();
 }

 public WorkItemInfo(WorkItemInfo workItemInfo)
 {
     _useCallerCallContext = workItemInfo._useCallerCallContext;
     _useCallerHttpContext = workItemInfo._useCallerHttpContext;
     _disposeOfStateObjects = workItemInfo._disposeOfStateObjects;
     _callToPostExecute = workItemInfo._callToPostExecute;
     _postExecuteWorkItemCallback = workItemInfo._postExecuteWorkItemCallback;
     _workItemPriority = workItemInfo._workItemPriority;
 }