<PackageReference Include="System.Threading.Tasks" Version="2.1.1" />

---

API Differences between 2.1.1 and 4.0.10-beta-22816

629 Additions 0 Removals

System

• public class AggregateException : Exception
  • public ReadOnlyCollection<Exception> InnerExceptions { get; }
  • public AggregateException()
  • public AggregateException(string message)
  • public AggregateException(string message, Exception innerException)
  • public AggregateException(Exception[] innerExceptions)
  • public AggregateException(string message, Exception[] innerExceptions)
  • public AggregateException(IEnumerable<Exception> innerExceptions)
  • public AggregateException(string message, IEnumerable<Exception> innerExceptions)
  • public AggregateException Flatten()
  • public void Handle(Func<Exception, bool> predicate)
• public static class ArrayExtensions
  • public static void CheckArray(this WaitHandle handle, WaitHandle[] handles, bool waitAll)
  • public static TTarget[] ConvertAll<TSrc, TTarget>(this TSrc[] src, Func<TSrc, TTarget> converter)
• public class OperationCanceledException : Exception
  • public CancellationToken CancellationToken { get; set; }
  • public OperationCanceledException()
  • public OperationCanceledException(string message)
  • public OperationCanceledException(CancellationToken token)
  • public OperationCanceledException(string message, Exception innerException)
• public static class Tuple
  • public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> Create<T1, T2, T3, T4, T5, T6, T7, T8>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, T8 item8)
  • public static Tuple<T1, T2, T3, T4, T5, T6, T7> Create<T1, T2, T3, T4, T5, T6, T7>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)
  • public static Tuple<T1, T2, T3, T4, T5, T6> Create<T1, T2, T3, T4, T5, T6>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)
  • public static Tuple<T1, T2, T3, T4, T5> Create<T1, T2, T3, T4, T5>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5)
  • public static Tuple<T1, T2, T3, T4> Create<T1, T2, T3, T4>(T1 item1, T2 item2, T3 item3, T4 item4)
  • public static Tuple<T1, T2, T3> Create<T1, T2, T3>(T1 item1, T2 item2, T3 item3)
  • public static Tuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2)
  • public static Tuple<T1> Create<T1>(T1 item1)
• public class Tuple<T1> : IStructuralEquatable, IStructuralComparable, IComparable
  • public T1 Item1 { get; }
  • public Tuple(T1 item1)
• public class Tuple<T1, T2> : IStructuralEquatable, IStructuralComparable, IComparable
  • public T1 Item1 { get; }
  • public T2 Item2 { get; }
  • public Tuple(T1 item1, T2 item2)
• public class Tuple<T1, T2, T3> : IStructuralEquatable, IStructuralComparable, IComparable
  • public T1 Item1 { get; }
  • public T2 Item2 { get; }
  • public T3 Item3 { get; }
  • public Tuple(T1 item1, T2 item2, T3 item3)
• public class Tuple<T1, T2, T3, T4> : IStructuralEquatable, IStructuralComparable, IComparable
  • public T1 Item1 { get; }
  • public T2 Item2 { get; }
  • public T3 Item3 { get; }
  • public T4 Item4 { get; }
  • public Tuple(T1 item1, T2 item2, T3 item3, T4 item4)
• public class Tuple<T1, T2, T3, T4, T5> : IStructuralEquatable, IStructuralComparable, IComparable
  • public T1 Item1 { get; }
  • public T2 Item2 { get; }
  • public T3 Item3 { get; }
  • public T4 Item4 { get; }
  • public T5 Item5 { get; }
  • public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5)
• public class Tuple<T1, T2, T3, T4, T5, T6> : IStructuralEquatable, IStructuralComparable, IComparable
  • public T1 Item1 { get; }
  • public T2 Item2 { get; }
  • public T3 Item3 { get; }
  • public T4 Item4 { get; }
  • public T5 Item5 { get; }
  • public T6 Item6 { get; }
  • public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)
• public class Tuple<T1, T2, T3, T4, T5, T6, T7> : IStructuralEquatable, IStructuralComparable, IComparable
  • public T1 Item1 { get; }
  • public T2 Item2 { get; }
  • public T3 Item3 { get; }
  • public T4 Item4 { get; }
  • public T5 Item5 { get; }
  • public T6 Item6 { get; }
  • public T7 Item7 { get; }
  • public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)
• public class Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> : IStructuralEquatable, IStructuralComparable, IComparable
  • public T1 Item1 { get; }
  • public T2 Item2 { get; }
  • public T3 Item3 { get; }
  • public T4 Item4 { get; }
  • public T5 Item5 { get; }
  • public T6 Item6 { get; }
  • public T7 Item7 { get; }
  • public TRest Rest { get; }
  • public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest)

System.Collections

• public interface IStructuralComparable
  • int CompareTo(object other, IComparer comparer)
• public interface IStructuralEquatable
  • bool Equals(object other, IEqualityComparer comparer)
  • int GetHashCode(IEqualityComparer comparer)

System.Collections.Concurrent

• public class BlockingCollection<T> : IEnumerable<T>, ICollection, IEnumerable, IDisposable
  • public int BoundedCapacity { get; }
  • public int Count { get; }
  • public bool IsAddingCompleted { get; }
  • public bool IsCompleted { get; }
  • public BlockingCollection()
  • public BlockingCollection(int upperBound)
  • public BlockingCollection(IProducerConsumerCollection<T> underlyingColl)
  • public BlockingCollection(IProducerConsumerCollection<T> underlyingColl, int upperBound)
  • public static int AddToAny(BlockingCollection<T>[] collections, T item)
  • public static int AddToAny(BlockingCollection<T>[] collections, T item, CancellationToken token)
  • public static int TakeFromAny(BlockingCollection<T>[] collections, out T item)
  • public static int TakeFromAny(BlockingCollection<T>[] collections, out T item, CancellationToken token)
  • public static int TryAddToAny(BlockingCollection<T>[] collections, T item)
  • public static int TryAddToAny(BlockingCollection<T>[] collections, T item, TimeSpan ts)
  • public static int TryAddToAny(BlockingCollection<T>[] collections, T item, int millisecondsTimeout)
  • public static int TryAddToAny(BlockingCollection<T>[] collections, T item, int millisecondsTimeout, CancellationToken token)
  • public static int TryTakeFromAny(BlockingCollection<T>[] collections, out T item)
  • public static int TryTakeFromAny(BlockingCollection<T>[] collections, out T item, TimeSpan ts)
  • public static int TryTakeFromAny(BlockingCollection<T>[] collections, out T item, int millisecondsTimeout)
  • public static int TryTakeFromAny(BlockingCollection<T>[] collections, out T item, int millisecondsTimeout, CancellationToken token)
  • public void Add(T item)
  • public void Add(T item, CancellationToken token)
  • public void CompleteAdding()
  • public void CopyTo(T[] array, int index)
  • public void Dispose()
  • protected virtual void Dispose(bool managedRes)
  • public IEnumerable<T> GetConsumingEnumerable()
  • public IEnumerable<T> GetConsumingEnumerable(CancellationToken token)
  • public T Take()
  • public T Take(CancellationToken token)
  • public T[] ToArray()
  • public bool TryAdd(T item)
  • public bool TryAdd(T item, TimeSpan ts)
  • public bool TryAdd(T item, int millisecondsTimeout)
  • public bool TryAdd(T item, int millisecondsTimeout, CancellationToken token)
  • public bool TryTake(out T item)
  • public bool TryTake(out T item, TimeSpan ts)
  • public bool TryTake(out T item, int millisecondsTimeout)
  • public bool TryTake(out T item, int millisecondsTimeout, CancellationToken token)
• public class ConcurrentDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IDictionary, ICollection, IEnumerable
  • public int Count { get; }
  • public bool IsEmpty { get; }
  • public TValue this[TKey key] { get; set; }
  • public ICollection<TKey> Keys { get; }
  • public ICollection<TValue> Values { get; }
  • public ConcurrentDictionary()
  • public ConcurrentDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection)
  • public ConcurrentDictionary(IEqualityComparer<TKey> comparer)
  • public ConcurrentDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey> comparer)
  • public ConcurrentDictionary(int concurrencyLevel, int capacity)
  • public ConcurrentDictionary(int concurrencyLevel, IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey> comparer)
  • public ConcurrentDictionary(int concurrencyLevel, int capacity, IEqualityComparer<TKey> comparer)
  • public TValue AddOrUpdate(TKey key, Func<TKey, TValue> addValueFactory, Func<TKey, TValue, TValue> updateValueFactory)
  • public TValue AddOrUpdate(TKey key, TValue addValue, Func<TKey, TValue, TValue> updateValueFactory)
  • public void Clear()
  • public bool ContainsKey(TKey key)
  • public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
  • public TValue GetOrAdd(TKey key, Func<TKey, TValue> valueFactory)
  • public TValue GetOrAdd(TKey key, TValue value)
  • public KeyValuePair<TKey, TValue>[] ToArray()
  • public bool TryAdd(TKey key, TValue value)
  • public bool TryGetValue(TKey key, out TValue value)
  • public bool TryRemove(TKey key, out TValue value)
  • public bool TryUpdate(TKey key, TValue newValue, TValue comparisonValue)
• public class ConcurrentOrderedList<T> : ICollection<T>, IEnumerable<T>, IEnumerable
  • public IEqualityComparer<T> Comparer { get; }
  • public int Count { get; }
  • public ConcurrentOrderedList()
  • public ConcurrentOrderedList(IEqualityComparer<T> comparer)
  • public void Clear()
  • public bool Contains(T data)
  • public bool ContainsHash(int key)
  • public void CopyTo(T[] array, int startIndex)
  • public bool TryAdd(T data)
  • public bool TryGetFromHash(int key, out T data)
  • public bool TryRemove(T data)
  • public bool TryRemoveHash(int key, out T data)
• public class ConcurrentQueue<T> : IProducerConsumerCollection<T>, IEnumerable<T>, ICollection, IEnumerable
  • public int Count { get; }
  • public bool IsEmpty { get; }
  • public ConcurrentQueue()
  • public ConcurrentQueue(IEnumerable<T> collection)
  • public void CopyTo(T[] array, int index)
  • public void Enqueue(T item)
  • public IEnumerator<T> GetEnumerator()
  • public T[] ToArray()
  • public bool TryDequeue(out T result)
  • public bool TryPeek(out T result)
• public class ConcurrentStack<T> : IProducerConsumerCollection<T>, IEnumerable<T>, ICollection, IEnumerable
  • public int Count { get; }
  • public bool IsEmpty { get; }
  • public ConcurrentStack()
  • public ConcurrentStack(IEnumerable<T> collection)
  • public void Clear()
  • public void CopyTo(T[] array, int index)
  • public IEnumerator<T> GetEnumerator()
  • public void Push(T item)
  • public void PushRange(T[] items)
  • public void PushRange(T[] items, int startIndex, int count)
  • public T[] ToArray()
  • public bool TryPeek(out T result)
  • public bool TryPop(out T result)
  • public int TryPopRange(T[] items)
  • public int TryPopRange(T[] items, int startIndex, int count)
• public interface IProducerConsumerCollection<T> : IEnumerable<T>, ICollection, IEnumerable
  • void CopyTo(T[] array, int index)
  • T[] ToArray()
  • bool TryAdd(T item)
  • bool TryTake(out T item)
• public abstract class OrderablePartitioner<TSource> : Partitioner<TSource>
  • public bool KeysNormalized { get; }
  • public bool KeysOrderedAcrossPartitions { get; }
  • public bool KeysOrderedInEachPartition { get; }
  • protected OrderablePartitioner(bool keysOrderedInEachPartition, bool keysOrderedAcrossPartitions, bool keysNormalized)
  • public virtual IEnumerable<KeyValuePair<long, TSource>> GetOrderableDynamicPartitions()
  • public abstract IList<IEnumerator<KeyValuePair<long, TSource>>> GetOrderablePartitions(int partitionCount)
• public static class Partitioner
  • public static OrderablePartitioner<TSource> Create<TSource>(IEnumerable<TSource> source)
  • public static OrderablePartitioner<TSource> Create<TSource>(TSource[] array, bool loadBalance)
  • public static OrderablePartitioner<TSource> Create<TSource>(IList<TSource> list, bool loadBalance)
  • public static OrderablePartitioner<Tuple<int, int>> Create(int fromInclusive, int toExclusive)
  • public static OrderablePartitioner<Tuple<int, int>> Create(int fromInclusive, int toExclusive, int rangeSize)
  • public static OrderablePartitioner<Tuple<long, long>> Create(long fromInclusive, long toExclusive)
  • public static OrderablePartitioner<Tuple<long, long>> Create(long fromInclusive, long toExclusive, long rangeSize)
• public abstract class Partitioner<TSource>
  • public virtual bool SupportsDynamicPartitions { get; }
  • protected Partitioner()
  • public virtual IEnumerable<TSource> GetDynamicPartitions()
  • public abstract IList<IEnumerator<TSource>> GetPartitions(int partitionCount)

System.Threading

• public struct CancellationToken
  • public static CancellationToken None { get; }
  • public bool CanBeCanceled { get; }
  • public bool IsCancellationRequested { get; }
  • public WaitHandle WaitHandle { get; }
  • public CancellationToken(bool canceled)
  • public static bool op_Equality(CancellationToken left, CancellationToken right)
  • public static bool op_Inequality(CancellationToken left, CancellationToken right)
  • public bool Equals(CancellationToken other)
  • public CancellationTokenRegistration Register(Action callback)
  • public CancellationTokenRegistration Register(Action callback, bool useSynchronizationContext)
  • public CancellationTokenRegistration Register(Action<object> callback, object state)
  • public CancellationTokenRegistration Register(Action<object> callback, object state, bool useSynchronizationContext)
  • public void ThrowIfCancellationRequested()
• public struct CancellationTokenRegistration : IDisposable, IEquatable<CancellationTokenRegistration>
  • public static bool op_Equality(CancellationTokenRegistration left, CancellationTokenRegistration right)
  • public static bool op_Inequality(CancellationTokenRegistration left, CancellationTokenRegistration right)
  • public void Dispose()
  • public bool Equals(CancellationTokenRegistration other)
• public sealed class CancellationTokenSource : IDisposable
  • public bool IsCancellationRequested { get; }
  • public CancellationToken Token { get; }
  • public CancellationTokenSource()
  • public static CancellationTokenSource CreateLinkedTokenSource(CancellationToken token1, CancellationToken token2)
  • public static CancellationTokenSource CreateLinkedTokenSource(CancellationToken[] tokens)
  • public void Cancel()
  • public void Cancel(bool throwOnFirstException)
  • public void Dispose()
• public class CountdownEvent : IDisposable
  • public int CurrentCount { get; }
  • public int InitialCount { get; }
  • public bool IsSet { get; }
  • public WaitHandle WaitHandle { get; }
  • public CountdownEvent(int initialCount)
  • public void AddCount()
  • public void AddCount(int signalCount)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
  • public void Reset()
  • public void Reset(int count)
  • public bool Signal()
  • public bool Signal(int signalCount)
  • public bool TryAddCount()
  • public bool TryAddCount(int signalCount)
  • public void Wait()
  • public void Wait(CancellationToken cancellationToken)
  • public bool Wait(int millisecondsTimeout)
  • public bool Wait(TimeSpan timeout)
  • public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)
  • public bool Wait(TimeSpan timeout, CancellationToken cancellationToken)
• public static class LazyInitializer
  • public static T EnsureInitialized<T>(ref T target)
  • public static T EnsureInitialized<T>(ref T target, Func<T> valueFactory)
  • public static T EnsureInitialized<T>(ref T target, ref bool initialized, ref object syncLock)
  • public static T EnsureInitialized<T>(ref T target, ref bool initialized, ref object syncLock, Func<T> valueFactory)
• public class ManualResetEventSlim : IDisposable
  • public bool IsSet { get; }
  • public int SpinCount { get; }
  • public WaitHandle WaitHandle { get; }
  • public ManualResetEventSlim()
  • public ManualResetEventSlim(bool initialState)
  • public ManualResetEventSlim(bool initialState, int spinCount)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
  • public void Reset()
  • public void Set()
  • public void Wait()
  • public bool Wait(int millisecondsTimeout)
  • public bool Wait(TimeSpan timeout)
  • public void Wait(CancellationToken cancellationToken)
  • public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)
  • public bool Wait(TimeSpan timeout, CancellationToken cancellationToken)
• public struct SpinWait
  • public int Count { get; }
  • public bool NextSpinWillYield { get; }
  • public static void SpinUntil(Func<bool> condition)
  • public static bool SpinUntil(Func<bool> condition, TimeSpan timeout)
  • public static bool SpinUntil(Func<bool> condition, int millisecondsTimeout)
  • public void Reset()
  • public void SpinOnce()
• public enum ThreadPriority
  • AboveNormal = 3
  • BelowNormal = 1
  • Highest = 4
  • Lowest = 0
  • Normal = 2

System.Threading.Tasks

• public interface IConcurrentDeque<T>
  • IEnumerable<T> GetEnumerable()
  • PopResult PopBottom(out T obj)
  • PopResult PopTop(out T obj)
  • void PushBottom(T obj)
• public static class Parallel
  • public static ParallelLoopResult For(int fromInclusive, int toExclusive, Action<int> body)
  • public static ParallelLoopResult For(int fromInclusive, int toExclusive, Action<int, ParallelLoopState> body)
  • public static ParallelLoopResult For(int fromInclusive, int toExclusive, ParallelOptions parallelOptions, Action<int> body)
  • public static ParallelLoopResult For(int fromInclusive, int toExclusive, ParallelOptions parallelOptions, Action<int, ParallelLoopState> body)
  • public static ParallelLoopResult For<TLocal>(int fromInclusive, int toExclusive, Func<TLocal> localInit, Func<int, ParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally)
  • public static ParallelLoopResult For<TLocal>(int fromInclusive, int toExclusive, ParallelOptions parallelOptions, Func<TLocal> localInit, Func<int, ParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally)
  • public static ParallelLoopResult For(long fromInclusive, long toExclusive, Action<long> body)
  • public static ParallelLoopResult For(long fromInclusive, long toExclusive, Action<long, ParallelLoopState> body)
  • public static ParallelLoopResult For(long fromInclusive, long toExclusive, ParallelOptions parallelOptions, Action<long> body)
  • public static ParallelLoopResult For(long fromInclusive, long toExclusive, ParallelOptions parallelOptions, Action<long, ParallelLoopState> body)
  • public static ParallelLoopResult For<TLocal>(long fromInclusive, long toExclusive, Func<TLocal> localInit, Func<long, ParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally)
  • public static ParallelLoopResult For<TLocal>(long fromInclusive, long toExclusive, ParallelOptions parallelOptions, Func<TLocal> localInit, Func<long, ParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally)
  • public static ParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source, Action<TSource> body)
  • public static ParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source, Action<TSource, ParallelLoopState> body)
  • public static ParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source, Action<TSource, ParallelLoopState, long> body)
  • public static ParallelLoopResult ForEach<TSource>(Partitioner<TSource> source, Action<TSource, ParallelLoopState> body)
  • public static ParallelLoopResult ForEach<TSource>(OrderablePartitioner<TSource> source, Action<TSource, ParallelLoopState, long> body)
  • public static ParallelLoopResult ForEach<TSource>(Partitioner<TSource> source, Action<TSource> body)
  • public static ParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source, ParallelOptions parallelOptions, Action<TSource> body)
  • public static ParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source, ParallelOptions parallelOptions, Action<TSource, ParallelLoopState> body)
  • public static ParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source, ParallelOptions parallelOptions, Action<TSource, ParallelLoopState, long> body)
  • public static ParallelLoopResult ForEach<TSource>(OrderablePartitioner<TSource> source, ParallelOptions parallelOptions, Action<TSource, ParallelLoopState, long> body)
  • public static ParallelLoopResult ForEach<TSource>(Partitioner<TSource> source, ParallelOptions parallelOptions, Action<TSource> body)
  • public static ParallelLoopResult ForEach<TSource>(Partitioner<TSource> source, ParallelOptions parallelOptions, Action<TSource, ParallelLoopState> body)
  • public static ParallelLoopResult ForEach<TSource, TLocal>(IEnumerable<TSource> source, Func<TLocal> localInit, Func<TSource, ParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally)
  • public static ParallelLoopResult ForEach<TSource, TLocal>(IEnumerable<TSource> source, Func<TLocal> localInit, Func<TSource, ParallelLoopState, long, TLocal, TLocal> body, Action<TLocal> localFinally)
  • public static ParallelLoopResult ForEach<TSource, TLocal>(OrderablePartitioner<TSource> source, Func<TLocal> localInit, Func<TSource, ParallelLoopState, long, TLocal, TLocal> body, Action<TLocal> localFinally)
  • public static ParallelLoopResult ForEach<TSource, TLocal>(Partitioner<TSource> source, Func<TLocal> localInit, Func<TSource, ParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally)
  • public static ParallelLoopResult ForEach<TSource, TLocal>(IEnumerable<TSource> source, ParallelOptions parallelOptions, Func<TLocal> localInit, Func<TSource, ParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally)
  • public static ParallelLoopResult ForEach<TSource, TLocal>(IEnumerable<TSource> source, ParallelOptions parallelOptions, Func<TLocal> localInit, Func<TSource, ParallelLoopState, long, TLocal, TLocal> body, Action<TLocal> localFinally)
  • public static ParallelLoopResult ForEach<TSource, TLocal>(Partitioner<TSource> source, ParallelOptions parallelOptions, Func<TLocal> localInit, Func<TSource, ParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally)
  • public static ParallelLoopResult ForEach<TSource, TLocal>(OrderablePartitioner<TSource> source, ParallelOptions parallelOptions, Func<TLocal> localInit, Func<TSource, ParallelLoopState, long, TLocal, TLocal> body, Action<TLocal> localFinally)
  • public static void Invoke(Action[] actions)
  • public static void Invoke(ParallelOptions parallelOptions, Action[] actions)
• public struct ParallelLoopResult
  • public bool IsCompleted { get; }
  • public long? LowestBreakIteration { get; }
• public class ParallelLoopState
  • public bool IsExceptional { get; }
  • public bool IsStopped { get; }
  • public long? LowestBreakIteration { get; }
  • public bool ShouldExitCurrentIteration { get; }
  • public void Break()
  • public void Stop()
• public class ParallelOptions
  • public CancellationToken CancellationToken { get; set; }
  • public int MaxDegreeOfParallelism { get; set; }
  • public TaskScheduler TaskScheduler { get; set; }
  • public ParallelOptions()
• public enum PopResult
  • Abort = 2
  • Empty = 1
  • Succeed = 0
• public class Task : IDisposable, IAsyncResult
  • public static int? CurrentId { get; }
  • public static TaskFactory Factory { get; }
  • public object AsyncState { get; }
  • public TaskCreationOptions CreationOptions { get; }
  • public AggregateException Exception { get; }
  • public int Id { get; }
  • public bool IsCanceled { get; }
  • public bool IsCompleted { get; }
  • public bool IsFaulted { get; }
  • public TaskStatus Status { get; }
  • public Task(Action action)
  • public Task(Action action, TaskCreationOptions creationOptions)
  • public Task(Action action, CancellationToken cancellationToken)
  • public Task(Action action, CancellationToken cancellationToken, TaskCreationOptions creationOptions)
  • public Task(Action<object> action, object state)
  • public Task(Action<object> action, object state, TaskCreationOptions creationOptions)
  • public Task(Action<object> action, object state, CancellationToken cancellationToken)
  • public Task(Action<object> action, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions)
  • public static void WaitAll(Task[] tasks)
  • public static void WaitAll(Task[] tasks, CancellationToken cancellationToken)
  • public static bool WaitAll(Task[] tasks, TimeSpan timeout)
  • public static bool WaitAll(Task[] tasks, int millisecondsTimeout)
  • public static bool WaitAll(Task[] tasks, int millisecondsTimeout, CancellationToken cancellationToken)
  • public static int WaitAny(Task[] tasks)
  • public static int WaitAny(Task[] tasks, TimeSpan timeout)
  • public static int WaitAny(Task[] tasks, int millisecondsTimeout)
  • public static int WaitAny(Task[] tasks, CancellationToken cancellationToken)
  • public static int WaitAny(Task[] tasks, int millisecondsTimeout, CancellationToken cancellationToken)
  • public Task ContinueWith(Action<Task> continuationAction)
  • public Task ContinueWith(Action<Task> continuationAction, TaskContinuationOptions continuationOptions)
  • public Task ContinueWith(Action<Task> continuationAction, CancellationToken cancellationToken)
  • public Task ContinueWith(Action<Task> continuationAction, TaskScheduler scheduler)
  • public Task ContinueWith(Action<Task> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
  • public Task<TResult> ContinueWith<TResult>(Func<Task, TResult> continuationFunction)
  • public Task<TResult> ContinueWith<TResult>(Func<Task, TResult> continuationFunction, TaskContinuationOptions continuationOptions)
  • public Task<TResult> ContinueWith<TResult>(Func<Task, TResult> continuationFunction, CancellationToken cancellationToken)
  • public Task<TResult> ContinueWith<TResult>(Func<Task, TResult> continuationFunction, TaskScheduler scheduler)
  • public Task<TResult> ContinueWith<TResult>(Func<Task, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
  • public void RunSynchronously()
  • public void RunSynchronously(TaskScheduler scheduler)
  • public void Start()
  • public void Start(TaskScheduler scheduler)
  • public void Wait()
  • public void Wait(CancellationToken cancellationToken)
  • public bool Wait(TimeSpan timeout)
  • public bool Wait(int millisecondsTimeout)
  • public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)
• public class Task<TResult> : Task
  • public static TaskFactory<TResult> Factory { get; }
  • public TResult Result { get; }
  • public Task(Func<TResult> function)
  • public Task(Func<TResult> function, CancellationToken cancellationToken)
  • public Task(Func<TResult> function, TaskCreationOptions creationOptions)
  • public Task(Func<TResult> function, CancellationToken cancellationToken, TaskCreationOptions creationOptions)
  • public Task(Func<object, TResult> function, object state)
  • public Task(Func<object, TResult> function, object state, CancellationToken cancellationToken)
  • public Task(Func<object, TResult> function, object state, TaskCreationOptions creationOptions)
  • public Task(Func<object, TResult> function, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions)
  • public Task ContinueWith(Action<Task<TResult>> continuationAction)
  • public Task ContinueWith(Action<Task<TResult>> continuationAction, TaskContinuationOptions continuationOptions)
  • public Task ContinueWith(Action<Task<TResult>> continuationAction, CancellationToken cancellationToken)
  • public Task ContinueWith(Action<Task<TResult>> continuationAction, TaskScheduler scheduler)
  • public Task ContinueWith(Action<Task<TResult>> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
  • public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, TNewResult> continuationFunction)
  • public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, TNewResult> continuationFunction, CancellationToken cancellationToken)
  • public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, TNewResult> continuationFunction, TaskContinuationOptions continuationOptions)
  • public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, TNewResult> continuationFunction, TaskScheduler scheduler)
  • public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, TNewResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
• public class TaskCanceledException : OperationCanceledException
  • public Task Task { get; }
  • public TaskCanceledException()
  • public TaskCanceledException(string message)
  • public TaskCanceledException(string message, Exception innerException)
  • public TaskCanceledException(Task task)
• public class TaskCompletionSource<TResult>
  • public Task<TResult> Task { get; }
  • public TaskCompletionSource()
  • public TaskCompletionSource(object state)
  • public TaskCompletionSource(TaskCreationOptions creationOptions)
  • public TaskCompletionSource(object state, TaskCreationOptions creationOptions)
  • public void SetCanceled()
  • public void SetException(Exception exception)
  • public void SetException(IEnumerable<Exception> exceptions)
  • public void SetResult(TResult result)
  • public bool TrySetCanceled()
  • public bool TrySetException(Exception exception)
  • public bool TrySetException(IEnumerable<Exception> exceptions)
  • public bool TrySetResult(TResult result)
• public enum TaskContinuationOptions
  • AttachedToParent = 4
  • ExecuteSynchronously = 524288
  • LongRunning = 2
  • None = 0
  • NotOnCanceled = 262144
  • NotOnFaulted = 131072
  • NotOnRanToCompletion = 65536
  • OnlyOnCanceled = 196608
  • OnlyOnFaulted = 327680
  • OnlyOnRanToCompletion = 393216
  • PreferFairness = 1
• public enum TaskCreationOptions
  • AttachedToParent = 4
  • LongRunning = 2
  • None = 0
  • PreferFairness = 1
• public static class TaskExtensions
  • public static Task<TResult> Unwrap<TResult>(this Task<Task<TResult>> task)
  • public static Task Unwrap(this Task<Task> task)
• public class TaskFactory
  • public CancellationToken CancellationToken { get; }
  • public TaskContinuationOptions ContinuationOptions { get; }
  • public TaskCreationOptions CreationOptions { get; }
  • public TaskScheduler Scheduler { get; }
  • public TaskFactory()
  • public TaskFactory(CancellationToken cancellationToken)
  • public TaskFactory(TaskScheduler scheduler)
  • public TaskFactory(TaskCreationOptions creationOptions, TaskContinuationOptions continuationOptions)
  • public TaskFactory(CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
  • public Task ContinueWhenAll(Task[] tasks, Action<Task[]> continuationAction)
  • public Task ContinueWhenAll(Task[] tasks, Action<Task[]> continuationAction, CancellationToken cancellationToken)
  • public Task ContinueWhenAll(Task[] tasks, Action<Task[]> continuationAction, TaskContinuationOptions continuationOptions)
  • public Task ContinueWhenAll(Task[] tasks, Action<Task[]> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
  • public Task ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>[]> continuationAction)
  • public Task ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>[]> continuationAction, CancellationToken cancellationToken)
  • public Task ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>[]> continuationAction, TaskContinuationOptions continuationOptions)
  • public Task ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>[]> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
  • public Task<TResult> ContinueWhenAll<TResult>(Task[] tasks, Func<Task[], TResult> continuationFunction)
  • public Task<TResult> ContinueWhenAll<TResult>(Task[] tasks, Func<Task[], TResult> continuationFunction, TaskContinuationOptions continuationOptions)
  • public Task<TResult> ContinueWhenAll<TResult>(Task[] tasks, Func<Task[], TResult> continuationFunction, CancellationToken cancellationToken)
  • public Task<TResult> ContinueWhenAll<TResult>(Task[] tasks, Func<Task[], TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
  • public Task<TResult> ContinueWhenAll<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction)
  • public Task<TResult> ContinueWhenAll<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction, TaskContinuationOptions continuationOptions)
  • public Task<TResult> ContinueWhenAll<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction, CancellationToken cancellationToken)
  • public Task<TResult> ContinueWhenAll<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
  • public Task ContinueWhenAny(Task[] tasks, Action<Task> continuationAction)
  • public Task ContinueWhenAny(Task[] tasks, Action<Task> continuationAction, CancellationToken cancellationToken)
  • public Task ContinueWhenAny(Task[] tasks, Action<Task> continuationAction, TaskContinuationOptions continuationOptions)
  • public Task ContinueWhenAny(Task[] tasks, Action<Task> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
  • public Task ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>> continuationAction)
  • public Task ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>> continuationAction, CancellationToken cancellationToken)
  • public Task ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>> continuationAction, TaskContinuationOptions continuationOptions)
  • public Task ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
  • public Task<TResult> ContinueWhenAny<TResult>(Task[] tasks, Func<Task, TResult> continuationFunction)
  • public Task<TResult> ContinueWhenAny<TResult>(Task[] tasks, Func<Task, TResult> continuationFunction, CancellationToken cancellationToken)
  • public Task<TResult> ContinueWhenAny<TResult>(Task[] tasks, Func<Task, TResult> continuationFunction, TaskContinuationOptions continuationOptions)
  • public Task<TResult> ContinueWhenAny<TResult>(Task[] tasks, Func<Task, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
  • public Task<TResult> ContinueWhenAny<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction)
  • public Task<TResult> ContinueWhenAny<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction, CancellationToken cancellationToken)
  • public Task<TResult> ContinueWhenAny<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction, TaskContinuationOptions continuationOptions)
  • public Task<TResult> ContinueWhenAny<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
  • public Task FromAsync(IAsyncResult asyncResult, Action<IAsyncResult> endMethod)
  • public Task FromAsync(IAsyncResult asyncResult, Action<IAsyncResult> endMethod, TaskCreationOptions creationOptions)
  • public Task FromAsync(IAsyncResult asyncResult, Action<IAsyncResult> endMethod, TaskCreationOptions creationOptions, TaskScheduler scheduler)
  • public Task<TResult> FromAsync<TResult>(IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod)
  • public Task<TResult> FromAsync<TResult>(IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions)
  • public Task<TResult> FromAsync<TResult>(IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions, TaskScheduler scheduler)
  • public Task FromAsync(Func<AsyncCallback, object, IAsyncResult> beginMethod, Action<IAsyncResult> endMethod, object state)
  • public Task FromAsync(Func<AsyncCallback, object, IAsyncResult> beginMethod, Action<IAsyncResult> endMethod, object state, TaskCreationOptions creationOptions)
  • public Task FromAsync<TArg1>(Func<TArg1, AsyncCallback, object, IAsyncResult> beginMethod, Action<IAsyncResult> endMethod, TArg1 arg1, object state)
  • public Task FromAsync<TArg1>(Func<TArg1, AsyncCallback, object, IAsyncResult> beginMethod, Action<IAsyncResult> endMethod, TArg1 arg1, object state, TaskCreationOptions creationOptions)
  • public Task FromAsync<TArg1, TArg2>(Func<TArg1, TArg2, AsyncCallback, object, IAsyncResult> beginMethod, Action<IAsyncResult> endMethod, TArg1 arg1, TArg2 arg2, object state)
  • public Task FromAsync<TArg1, TArg2>(Func<TArg1, TArg2, AsyncCallback, object, IAsyncResult> beginMethod, Action<IAsyncResult> endMethod, TArg1 arg1, TArg2 arg2, object state, TaskCreationOptions creationOptions)
  • public Task<TResult> FromAsync<TResult>(Func<AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, object state)
  • public Task<TResult> FromAsync<TResult>(Func<AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, object state, TaskCreationOptions creationOptions)
  • public Task<TResult> FromAsync<TArg1, TResult>(Func<TArg1, AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, object state)
  • public Task<TResult> FromAsync<TArg1, TResult>(Func<TArg1, AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, object state, TaskCreationOptions creationOptions)
  • public Task<TResult> FromAsync<TArg1, TArg2, TResult>(Func<TArg1, TArg2, AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, object state)
  • public Task<TResult> FromAsync<TArg1, TArg2, TResult>(Func<TArg1, TArg2, AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, object state, TaskCreationOptions creationOptions)
  • public Task StartNew(Action action)
  • public Task StartNew(Action action, CancellationToken cancellationToken)
  • public Task StartNew(Action action, TaskCreationOptions creationOptions)
  • public Task StartNew(Action<object> action, object state)
  • public Task StartNew(Action<object> action, object state, CancellationToken cancellationToken)
  • public Task StartNew(Action<object> action, object state, TaskCreationOptions creationOptions)
  • public Task StartNew(Action action, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
  • public Task StartNew(Action<object> action, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
  • public Task<TResult> StartNew<TResult>(Func<TResult> function)
  • public Task<TResult> StartNew<TResult>(Func<TResult> function, TaskCreationOptions creationOptions)
  • public Task<TResult> StartNew<TResult>(Func<TResult> function, CancellationToken cancellationToken)
  • public Task<TResult> StartNew<TResult>(Func<TResult> function, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
  • public Task<TResult> StartNew<TResult>(Func<object, TResult> function, object state)
  • public Task<TResult> StartNew<TResult>(Func<object, TResult> function, object state, CancellationToken cancellationToken)
  • public Task<TResult> StartNew<TResult>(Func<object, TResult> function, object state, TaskCreationOptions creationOptions)
  • public Task<TResult> StartNew<TResult>(Func<object, TResult> function, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
• public class TaskFactory<TResult>
  • public CancellationToken CancellationToken { get; }
  • public TaskContinuationOptions ContinuationOptions { get; }
  • public TaskCreationOptions CreationOptions { get; }
  • public TaskScheduler Scheduler { get; }
  • public TaskFactory()
  • public TaskFactory(TaskScheduler scheduler)
  • public TaskFactory(CancellationToken cancellationToken)
  • public TaskFactory(TaskCreationOptions creationOptions, TaskContinuationOptions continuationOptions)
  • public TaskFactory(CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
  • public Task<TResult> ContinueWhenAll(Task[] tasks, Func<Task[], TResult> continuationFunction)
  • public Task<TResult> ContinueWhenAll(Task[] tasks, Func<Task[], TResult> continuationFunction, TaskContinuationOptions continuationOptions)
  • public Task<TResult> ContinueWhenAll(Task[] tasks, Func<Task[], TResult> continuationFunction, CancellationToken cancellationToken)
  • public Task<TResult> ContinueWhenAll(Task[] tasks, Func<Task[], TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
  • public Task<TResult> ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction)
  • public Task<TResult> ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction, TaskContinuationOptions continuationOptions)
  • public Task<TResult> ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction, CancellationToken cancellationToken)
  • public Task<TResult> ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
  • public Task<TResult> ContinueWhenAny(Task[] tasks, Func<Task, TResult> continuationFunction)
  • public Task<TResult> ContinueWhenAny(Task[] tasks, Func<Task, TResult> continuationFunction, CancellationToken cancellationToken)
  • public Task<TResult> ContinueWhenAny(Task[] tasks, Func<Task, TResult> continuationFunction, TaskContinuationOptions continuationOptions)
  • public Task<TResult> ContinueWhenAny(Task[] tasks, Func<Task, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
  • public Task<TResult> ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction)
  • public Task<TResult> ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction, CancellationToken cancellationToken)
  • public Task<TResult> ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction, TaskContinuationOptions continuationOptions)
  • public Task<TResult> ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
  • public Task<TResult> FromAsync(IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod)
  • public Task<TResult> FromAsync(IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions)
  • public Task<TResult> FromAsync(IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions, TaskScheduler scheduler)
  • public Task<TResult> FromAsync(Func<AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, object state)
  • public Task<TResult> FromAsync(Func<AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, object state, TaskCreationOptions creationOptions)
  • public Task<TResult> FromAsync<TArg1>(Func<TArg1, AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, object state)
  • public Task<TResult> FromAsync<TArg1>(Func<TArg1, AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, object state, TaskCreationOptions creationOptions)
  • public Task<TResult> FromAsync<TArg1, TArg2>(Func<TArg1, TArg2, AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, object state)
  • public Task<TResult> FromAsync<TArg1, TArg2>(Func<TArg1, TArg2, AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, object state, TaskCreationOptions creationOptions)
  • public Task<TResult> StartNew(Func<TResult> function)
  • public Task<TResult> StartNew(Func<TResult> function, TaskCreationOptions creationOptions)
  • public Task<TResult> StartNew(Func<TResult> function, CancellationToken cancellationToken)
  • public Task<TResult> StartNew(Func<TResult> function, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
  • public Task<TResult> StartNew(Func<object, TResult> function, object state)
  • public Task<TResult> StartNew(Func<object, TResult> function, object state, TaskCreationOptions creationOptions)
  • public Task<TResult> StartNew(Func<object, TResult> function, object state, CancellationToken cancellationToken)
  • public Task<TResult> StartNew(Func<object, TResult> function, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
• public abstract class TaskScheduler
  • public static TaskScheduler Current { get; }
  • public static TaskScheduler Default { get; }
  • public int Id { get; }
  • public virtual int MaximumConcurrencyLevel { get; }
  • public static event EventHandler<UnobservedTaskExceptionEventArgs> UnobservedTaskException
  • protected TaskScheduler()
  • public static TaskScheduler FromCurrentSynchronizationContext()
  • protected abstract IEnumerable<Task> GetScheduledTasks()
  • protected abstract bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
• public class TaskSchedulerException : Exception
  • public TaskSchedulerException()
  • public TaskSchedulerException(string message)
  • public TaskSchedulerException(Exception innerException)
  • public TaskSchedulerException(string message, Exception innerException)
• public enum TaskStatus
  • Canceled = 6
  • Created = 0
  • Faulted = 7
  • RanToCompletion = 5
  • Running = 3
  • WaitingForActivation = 1
  • WaitingForChildrenToComplete = 4
  • WaitingToRun = 2
• public class ThreadWorker : IDisposable
  • public bool Finished { get; }
  • public int Id { get; }
  • public ThreadWorker(ThreadWorker[] others, int workerPosition, IProducerConsumerCollection<Task> sharedWorkQueue, IConcurrentDeque<Task> dDeque, ThreadPriority priority, ManualResetEvent handle)
  • public static void ParticipativeWorkerMethod(Task self, ManualResetEventSlim predicateEvt, int millisecondsTimeout, IProducerConsumerCollection<Task> sharedWorkQueue, ThreadWorker[] others, ManualResetEvent evt)
  • public void Dispose()
  • public virtual bool Equals(ThreadWorker other)
  • public void Pulse()
  • public void Stop()
• public class UnobservedTaskExceptionEventArgs : EventArgs
  • public AggregateException Exception { get; }
  • public bool Observed { get; }
  • public UnobservedTaskExceptionEventArgs(AggregateException exception)
  • public void SetObserved()