Internal static Task t_currentTask // The currently executing task. Public class Task : IThreadPoolWorkItem, IAsyncResult, IDisposable Finally, for debuggers that parse stack frames, the /// InternalWait method serves a potential marker for when a Task is entering a wait operation. The m_action System.Object /// field stores a reference to the Task's delegate, and the m_stateObject System.Object field stores the /// async state passed to the Task by the developer. Similarly, the /// Int32 m_stateFlags field stores information about the current lifecycle stage of the Task, /// information also accessible through the property.
The Int32 m_taskId field serves as the backing /// store for the property, however accessing this field directly from a debugger may be /// more efficient than accessing the same value through the property's getter method (the /// s_taskIdCounter Int32 counter is used to retrieve the next available ID for a Task). / /// /// For developers implementing custom debuggers, several internal and private members of Task may be /// useful (these may change from release to release). / /// /// For operations that return values, the class /// should be used. / /// /// All members of, except for, are thread-safe /// and may be used from multiple threads concurrently. For performance reasons, TaskFactory's StartNew method should be the /// preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation /// and scheduling must be separated, the constructors may be used, and the task's /// method may then be used to schedule the task for execution at a later time. For example, to create a that runs an action, the factory's StartNew /// method may be used: /// /// // C# /// var t = (() => DoAction()) /// /// ' Visual Basic /// Dim t = (Function() DoAction()) /// /// /// /// The class also provides constructors that initialize the Task but that do not /// schedule it for execution. The most common approach is by /// using the Task type's property to retrieve a instance that can be used to create tasks for several /// purposes. / /// /// /// instances may be created in a variety of ways. / /// Represents an asynchronous operation. / /// The task completed due to an unhandled exception. / /// The task acknowledged cancellation by throwing an OperationCanceledException with its own CancellationToken /// while the token was in signaled state, or the task's CancellationToken was already signaled before the /// task started executing. / /// The task completed execution successfully. /// // Blocked, /// /// The task has finished executing and is implicitly waiting for /// attached child tasks to complete.
/// // /// The task is currently blocked in a wait state.
/ /// The task is running but has not yet completed. / /// The task has been scheduled for execution but has not yet begun executing. / /// The task is waiting to be activated and scheduled internally by the. / /// The task has been initialized but has not yet been scheduled. / /// Represents the current stage in the lifecycle of a. / /// Utility class for allocating structs as heap variables /// internal class Shared Disable the "reference to volatile field not treated as volatile" error. =++= // // Copyright (c) Microsoft Corporation.
0 kommentar(er)
