Silverlight 5

WinRT

	sealed enum TplEtwProvider
	: IComparable, IFormattable, IConvertible
	{ ParallelInvoke, ParallelFor, ParallelForEach }

	public abstract sealed class Parallel
	static public ParallelLoopResult For(Int32 fromInclusive, Int32 toExclusive, Action`1<Int32> body);
	static public ParallelLoopResult For(Int64 fromInclusive, Int64 toExclusive, Action`1<Int64> body);
	static public ParallelLoopResult For(Int32 fromInclusive, Int32 toExclusive, ParallelOptions parallelOptions, Action`1<Int32> body);
	static public ParallelLoopResult For(Int64 fromInclusive, Int64 toExclusive, ParallelOptions parallelOptions, Action`1<Int64> body);
	static public ParallelLoopResult For(Int32 fromInclusive, Int32 toExclusive, Action`2<Int32, ParallelLoopState> body);
	static public ParallelLoopResult For(Int64 fromInclusive, Int64 toExclusive, Action`2<Int64, ParallelLoopState> body);
	static public ParallelLoopResult For(Int32 fromInclusive, Int32 toExclusive, ParallelOptions parallelOptions, Action`2<Int32, ParallelLoopState> body);
	static public ParallelLoopResult For(Int64 fromInclusive, Int64 toExclusive, ParallelOptions parallelOptions, Action`2<Int64, ParallelLoopState> body);
	static public ParallelLoopResult For(Int32 fromInclusive, Int32 toExclusive, Func`1<TLocal> localInit, Func`4<Int32, ParallelLoopState, TLocal, TLocal> body, Action`1<TLocal> localFinally);
	static public ParallelLoopResult For(Int64 fromInclusive, Int64 toExclusive, Func`1<TLocal> localInit, Func`4<Int64, ParallelLoopState, TLocal, TLocal> body, Action`1<TLocal> localFinally);
	static public ParallelLoopResult For(Int32 fromInclusive, Int32 toExclusive, ParallelOptions parallelOptions, Func`1<TLocal> localInit, Func`4<Int32, ParallelLoopState, TLocal, TLocal> body, Action`1<TLocal> localFinally);
	static public ParallelLoopResult For(Int64 fromInclusive, Int64 toExclusive, ParallelOptions parallelOptions, Func`1<TLocal> localInit, Func`4<Int64, ParallelLoopState, TLocal, TLocal> body, Action`1<TLocal> localFinally);
	static public ParallelLoopResult ForEach(IEnumerable`1<TSource> source, Action`1<TSource> body);
	static public ParallelLoopResult ForEach(IEnumerable`1<TSource> source, ParallelOptions parallelOptions, Action`1<TSource> body);
	static public ParallelLoopResult ForEach(IEnumerable`1<TSource> source, Action`2<TSource, ParallelLoopState> body);
	static public ParallelLoopResult ForEach(IEnumerable`1<TSource> source, ParallelOptions parallelOptions, Action`2<TSource, ParallelLoopState> body);
	static public ParallelLoopResult ForEach(IEnumerable`1<TSource> source, Action`3<TSource, ParallelLoopState, Int64> body);
	static public ParallelLoopResult ForEach(IEnumerable`1<TSource> source, ParallelOptions parallelOptions, Action`3<TSource, ParallelLoopState, Int64> body);
	static public ParallelLoopResult ForEach(IEnumerable`1<TSource> source, Func`1<TLocal> localInit, Func`4<TSource, ParallelLoopState, TLocal, TLocal> body, Action`1<TLocal> localFinally);
	static public ParallelLoopResult ForEach(IEnumerable`1<TSource> source, ParallelOptions parallelOptions, Func`1<TLocal> localInit, Func`4<TSource, ParallelLoopState, TLocal, TLocal> body, Action`1<TLocal> localFinally);
	static public ParallelLoopResult ForEach(IEnumerable`1<TSource> source, Func`1<TLocal> localInit, Func`5<TSource, ParallelLoopState, Int64, TLocal, TLocal> body, Action`1<TLocal> localFinally);
	static public ParallelLoopResult ForEach(IEnumerable`1<TSource> source, ParallelOptions parallelOptions, Func`1<TLocal> localInit, Func`5<TSource, ParallelLoopState, Int64, TLocal, TLocal> body, Action`1<TLocal> localFinally);
	static public ParallelLoopResult ForEach(Partitioner`1<TSource> source, Action`1<TSource> body);
	static public ParallelLoopResult ForEach(Partitioner`1<TSource> source, Action`2<TSource, ParallelLoopState> body);
	static public ParallelLoopResult ForEach(OrderablePartitioner`1<TSource> source, Action`3<TSource, ParallelLoopState, Int64> body);
	static public ParallelLoopResult ForEach(Partitioner`1<TSource> source, Func`1<TLocal> localInit, Func`4<TSource, ParallelLoopState, TLocal, TLocal> body, Action`1<TLocal> localFinally);
	static public ParallelLoopResult ForEach(OrderablePartitioner`1<TSource> source, Func`1<TLocal> localInit, Func`5<TSource, ParallelLoopState, Int64, TLocal, TLocal> body, Action`1<TLocal> localFinally);
	static public ParallelLoopResult ForEach(Partitioner`1<TSource> source, ParallelOptions parallelOptions, Action`1<TSource> body);
	static public ParallelLoopResult ForEach(Partitioner`1<TSource> source, ParallelOptions parallelOptions, Action`2<TSource, ParallelLoopState> body);
	static public ParallelLoopResult ForEach(OrderablePartitioner`1<TSource> source, ParallelOptions parallelOptions, Action`3<TSource, ParallelLoopState, Int64> body);
	static public ParallelLoopResult ForEach(Partitioner`1<TSource> source, ParallelOptions parallelOptions, Func`1<TLocal> localInit, Func`4<TSource, ParallelLoopState, TLocal, TLocal> body, Action`1<TLocal> localFinally);
	static public ParallelLoopResult ForEach(OrderablePartitioner`1<TSource> source, ParallelOptions parallelOptions, Func`1<TLocal> localInit, Func`5<TSource, ParallelLoopState, Int64, TLocal, TLocal> body, Action`1<TLocal> localFinally);
	static public void Invoke(Action actions);
	static public void Invoke(ParallelOptions parallelOptions, Action actions);

	public sealed struct ParallelLoopResult
	: ValueType
	public Boolean IsCompleted { get; }
	public Nullable`1<Int64> LowestBreakIteration { get; }

	public class ParallelLoopState
	public Boolean IsExceptional { get; }
	public Boolean IsStopped { get; }
	public Nullable`1<Int64> LowestBreakIteration { get; }
	public Boolean ShouldExitCurrentIteration { get; }
	public void Break();
	public void Stop();

	public class ParallelOptions
	public CancellationToken CancellationToken { get; set; }
	public Int32 MaxDegreeOfParallelism { get; set; }
	public TaskScheduler TaskScheduler { get; set; }

public class Task	public class Task
: IThreadPoolWorkItem, IAsyncResult, IDisposable	: IThreadPoolWorkItem, IAsyncResult, IDisposable
public virtual Object AsyncState { get; }	public virtual Object AsyncState { get; }
public TaskCreationOptions CreationOptions { get; }	public TaskCreationOptions CreationOptions { get; }
static public Nullable`1<Int32> CurrentId { get; }	static public Nullable`1<Int32> CurrentId { get; }
public AggregateException Exception { get; }	public AggregateException Exception { get; }
static public TaskFactory Factory { get; }	static public TaskFactory Factory { get; }
public Int32 Id { get; }	public Int32 Id { get; }
public Boolean IsCanceled { get; }	public Boolean IsCanceled { get; }
public virtual Boolean IsCompleted { get; }	public virtual Boolean IsCompleted { get; }
public Boolean IsFaulted { get; }	public Boolean IsFaulted { get; }
public TaskStatus Status { get; }	public TaskStatus Status { get; }
	public ConfiguredTaskAwaitable ConfigureAwait(Boolean continueOnCapturedContext);
public Task ContinueWith(Action`1<Task> continuationAction);	public Task ContinueWith(Action`1<Task> continuationAction);
public Task ContinueWith(Action`1<Task> continuationAction, CancellationToken cancellationToken);	public Task ContinueWith(Action`1<Task> continuationAction, CancellationToken cancellationToken);
public Task ContinueWith(Action`1<Task> continuationAction, TaskScheduler scheduler);	public Task ContinueWith(Action`1<Task> continuationAction, TaskScheduler scheduler);
public Task ContinueWith(Action`1<Task> continuationAction, TaskContinuationOptions continuationOptions);	public Task ContinueWith(Action`1<Task> continuationAction, TaskContinuationOptions continuationOptions);
public Task ContinueWith(Action`1<Task> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);	public Task ContinueWith(Action`1<Task> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
	public Task ContinueWith(Action`2<Task, Object> continuationAction, Object state);
	public Task ContinueWith(Action`2<Task, Object> continuationAction, Object state, CancellationToken cancellationToken);
	public Task ContinueWith(Action`2<Task, Object> continuationAction, Object state, TaskScheduler scheduler);
	public Task ContinueWith(Action`2<Task, Object> continuationAction, Object state, TaskContinuationOptions continuationOptions);
	public Task ContinueWith(Action`2<Task, Object> continuationAction, Object state, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
public Task`1<TResult> ContinueWith(Func`2<Task, TResult> continuationFunction);	public Task`1<TResult> ContinueWith(Func`2<Task, TResult> continuationFunction);
public Task`1<TResult> ContinueWith(Func`2<Task, TResult> continuationFunction, CancellationToken cancellationToken);	public Task`1<TResult> ContinueWith(Func`2<Task, TResult> continuationFunction, CancellationToken cancellationToken);
public Task`1<TResult> ContinueWith(Func`2<Task, TResult> continuationFunction, TaskScheduler scheduler);	public Task`1<TResult> ContinueWith(Func`2<Task, TResult> continuationFunction, TaskScheduler scheduler);
public Task`1<TResult> ContinueWith(Func`2<Task, TResult> continuationFunction, TaskContinuationOptions continuationOptions);	public Task`1<TResult> ContinueWith(Func`2<Task, TResult> continuationFunction, TaskContinuationOptions continuationOptions);
public Task`1<TResult> ContinueWith(Func`2<Task, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);	public Task`1<TResult> ContinueWith(Func`2<Task, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
	public Task`1<TResult> ContinueWith(Func`3<Task, Object, TResult> continuationFunction, Object state);
	public Task`1<TResult> ContinueWith(Func`3<Task, Object, TResult> continuationFunction, Object state, CancellationToken cancellationToken);
	public Task`1<TResult> ContinueWith(Func`3<Task, Object, TResult> continuationFunction, Object state, TaskScheduler scheduler);
	public Task`1<TResult> ContinueWith(Func`3<Task, Object, TResult> continuationFunction, Object state, TaskContinuationOptions continuationOptions);
	public Task`1<TResult> ContinueWith(Func`3<Task, Object, TResult> continuationFunction, Object state, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
	static public Task Delay(TimeSpan delay);
	static public Task Delay(TimeSpan delay, CancellationToken cancellationToken);
	static public Task Delay(Int32 millisecondsDelay);
	static public Task Delay(Int32 millisecondsDelay, CancellationToken cancellationToken);
public virtual void Dispose();	public virtual void Dispose();
	protected virtual void Dispose(Boolean disposing);
	static public Task`1<TResult> FromResult(TResult result);
	public TaskAwaiter GetAwaiter();
	static public Task Run(Action action);
	static public Task Run(Action action, CancellationToken cancellationToken);
	static public Task`1<TResult> Run(Func`1<TResult> function);
	static public Task`1<TResult> Run(Func`1<TResult> function, CancellationToken cancellationToken);
	static public Task Run(Func`1<Task> function);
	static public Task Run(Func`1<Task> function, CancellationToken cancellationToken);
	static public Task`1<TResult> Run(Func`1<Task`1<TResult>> function);
	static public Task`1<TResult> Run(Func`1<Task`1<TResult>> function, CancellationToken cancellationToken);
public void RunSynchronously();	public void RunSynchronously();
public void RunSynchronously(TaskScheduler scheduler);	public void RunSynchronously(TaskScheduler scheduler);
public void Start();	public void Start();
public void Start(TaskScheduler scheduler);	public void Start(TaskScheduler scheduler);
public void Wait();	public void Wait();
public Boolean Wait(TimeSpan timeout);	public Boolean Wait(TimeSpan timeout);
public void Wait(CancellationToken cancellationToken);	public void Wait(CancellationToken cancellationToken);
public Boolean Wait(Int32 millisecondsTimeout);	public Boolean Wait(Int32 millisecondsTimeout);
public Boolean Wait(Int32 millisecondsTimeout, CancellationToken cancellationToken);	public Boolean Wait(Int32 millisecondsTimeout, CancellationToken cancellationToken);
static public void WaitAll(Task tasks);	static public void WaitAll(Task tasks);
static public Boolean WaitAll(Task tasks, TimeSpan timeout);	static public Boolean WaitAll(Task tasks, TimeSpan timeout);
static public Boolean WaitAll(Task tasks, Int32 millisecondsTimeout);	static public Boolean WaitAll(Task tasks, Int32 millisecondsTimeout);
static public void WaitAll(Task tasks, CancellationToken cancellationToken);	static public void WaitAll(Task tasks, CancellationToken cancellationToken);
static public Boolean WaitAll(Task tasks, Int32 millisecondsTimeout, CancellationToken cancellationToken);	static public Boolean WaitAll(Task tasks, Int32 millisecondsTimeout, CancellationToken cancellationToken);
static public Int32 WaitAny(Task tasks);	static public Int32 WaitAny(Task tasks);
static public Int32 WaitAny(Task tasks, TimeSpan timeout);	static public Int32 WaitAny(Task tasks, TimeSpan timeout);
static public Int32 WaitAny(Task tasks, CancellationToken cancellationToken);	static public Int32 WaitAny(Task tasks, CancellationToken cancellationToken);
static public Int32 WaitAny(Task tasks, Int32 millisecondsTimeout);	static public Int32 WaitAny(Task tasks, Int32 millisecondsTimeout);
static public Int32 WaitAny(Task tasks, Int32 millisecondsTimeout, CancellationToken cancellationToken);	static public Int32 WaitAny(Task tasks, Int32 millisecondsTimeout, CancellationToken cancellationToken);
	static public Task WhenAll(IEnumerable`1<Task> tasks);
	static public Task WhenAll(Task tasks);
	static public Task`1<TResult> WhenAll(IEnumerable`1<Task`1<TResult>> tasks);
	static public Task`1<TResult> WhenAll(Task`1[] tasks);
	static public Task`1<Task> WhenAny(Task tasks);
	static public Task`1<Task> WhenAny(IEnumerable`1<Task> tasks);
	static public Task`1<Task`1<TResult>> WhenAny(Task`1 tasks);
	static public Task`1<Task`1<TResult>> WhenAny(IEnumerable`1<Task`1<TResult>> tasks);

public class Task`1<TResult>	public class Task`1<TResult>
: Task, IThreadPoolWorkItem, IAsyncResult, IDisposable	: Task, IThreadPoolWorkItem, IAsyncResult, IDisposable
static public TaskFactory`1<TResult> Factory { get; }	static public TaskFactory`1<TResult> Factory { get; }
public TResult Result { get; }	public TResult Result { get; }
	public ConfiguredTaskAwaitable`1<TResult> ConfigureAwait(Boolean continueOnCapturedContext);
public Task ContinueWith(Action`1<Task`1<TResult>> continuationAction);	public Task`1<TNewResult> ContinueWith(Func`2<Task`1<>, TNewResult> continuationFunction, TaskContinuationOptions continuationOptions);
public Task ContinueWith(Action`1<Task`1<TResult>> continuationAction, CancellationToken cancellationToken);	public Task`1<TNewResult> ContinueWith(Func`2<Task`1<>, TNewResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
public Task ContinueWith(Action`1<Task`1<TResult>> continuationAction, TaskScheduler scheduler);	public Task ContinueWith(Action`1<Task`1<>> continuationAction);
public Task ContinueWith(Action`1<Task`1<TResult>> continuationAction, TaskContinuationOptions continuationOptions);	public Task ContinueWith(Action`1<Task`1<>> continuationAction, CancellationToken cancellationToken);
public Task ContinueWith(Action`1<Task`1<TResult>> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);	public Task ContinueWith(Action`1<Task`1<>> continuationAction, TaskScheduler scheduler);
public Task`1<TNewResult> ContinueWith(Func`2<Task`1<TResult>, TNewResult> continuationFunction);	public Task ContinueWith(Action`1<Task`1<>> continuationAction, TaskContinuationOptions continuationOptions);
public Task`1<TNewResult> ContinueWith(Func`2<Task`1<TResult>, TNewResult> continuationFunction, CancellationToken cancellationToken);	public Task ContinueWith(Action`1<Task`1<>> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
public Task`1<TNewResult> ContinueWith(Func`2<Task`1<TResult>, TNewResult> continuationFunction, TaskScheduler scheduler);	public Task ContinueWith(Action`2<Task`1<>, Object> continuationAction, Object state);
public Task`1<TNewResult> ContinueWith(Func`2<Task`1<TResult>, TNewResult> continuationFunction, TaskContinuationOptions continuationOptions);	public Task ContinueWith(Action`2<Task`1<>, Object> continuationAction, Object state, CancellationToken cancellationToken);
public Task`1<TNewResult> ContinueWith(Func`2<Task`1<TResult>, TNewResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);	public Task ContinueWith(Action`2<Task`1<>, Object> continuationAction, Object state, TaskScheduler scheduler);
	public Task ContinueWith(Action`2<Task`1<>, Object> continuationAction, Object state, TaskContinuationOptions continuationOptions);
	public Task ContinueWith(Action`2<Task`1<>, Object> continuationAction, Object state, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
	public Task`1<TNewResult> ContinueWith(Func`2<Task`1<>, TNewResult> continuationFunction);
	public Task`1<TNewResult> ContinueWith(Func`2<Task`1<>, TNewResult> continuationFunction, CancellationToken cancellationToken);
	public Task`1<TNewResult> ContinueWith(Func`2<Task`1<>, TNewResult> continuationFunction, TaskScheduler scheduler);
	public Task`1<TNewResult> ContinueWith(Func`3<Task`1<>, Object, TNewResult> continuationFunction, Object state);
	public Task`1<TNewResult> ContinueWith(Func`3<Task`1<>, Object, TNewResult> continuationFunction, Object state, CancellationToken cancellationToken);
	public Task`1<TNewResult> ContinueWith(Func`3<Task`1<>, Object, TNewResult> continuationFunction, Object state, TaskScheduler scheduler);
	public Task`1<TNewResult> ContinueWith(Func`3<Task`1<>, Object, TNewResult> continuationFunction, Object state, TaskContinuationOptions continuationOptions);
	public Task`1<TNewResult> ContinueWith(Func`3<Task`1<>, Object, TNewResult> continuationFunction, Object state, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);

public class TaskCanceledException	public class TaskCanceledException
: OperationCanceledException, _Exception	: OperationCanceledException, ISerializable, _Exception
public Task Task { get; }	public Task Task { get; }

public class TaskCompletionSource`1<TResult>	public class TaskCompletionSource`1<TResult>
public Task`1<TResult> Task { get; }	public Task`1<TResult> Task { get; }
public void SetCanceled();	public void SetCanceled();
public void SetException(Exception exception);	public void SetException(Exception exception);
public void SetException(IEnumerable`1<Exception> exceptions);	public void SetException(IEnumerable`1<Exception> exceptions);
public void SetResult(TResult result);	public void SetResult(TResult result);
public Boolean TrySetCanceled();	public Boolean TrySetCanceled();
public Boolean TrySetException(Exception exception);	public Boolean TrySetException(Exception exception);
public Boolean TrySetException(IEnumerable`1<Exception> exceptions);	public Boolean TrySetException(IEnumerable`1<Exception> exceptions);
public Boolean TrySetResult(TResult result);	public Boolean TrySetResult(TResult result);

public sealed enum TaskContinuationOptions	public sealed enum TaskContinuationOptions
: IComparable, IFormattable, IConvertible	: IComparable, IFormattable, IConvertible
{ None, PreferFairness, LongRunning, AttachedToParent, NotOnRanToCompletion, NotOnFaulted, NotOnCanceled, OnlyOnRanToCompletion, OnlyOnFaulted, OnlyOnCanceled, ExecuteSynchronously }	{ None, PreferFairness, LongRunning, AttachedToParent, DenyChildAttach, HideScheduler, NotOnRanToCompletion, NotOnFaulted, NotOnCanceled, OnlyOnRanToCompletion, OnlyOnFaulted, OnlyOnCanceled, ExecuteSynchronously }

public sealed enum TaskCreationOptions	public sealed enum TaskCreationOptions
: IComparable, IFormattable, IConvertible	: IComparable, IFormattable, IConvertible
{ None, PreferFairness, LongRunning, AttachedToParent }	{ None, PreferFairness, LongRunning, AttachedToParent, DenyChildAttach, HideScheduler }

public abstract sealed class TaskExtensions	public abstract sealed class TaskExtensions
static public Task Unwrap(Task`1<Task> task);	static public Task Unwrap(Task`1<Task> task);
static public Task`1<TResult> Unwrap(Task`1<Task`1<TResult>> task);	static public Task`1<TResult> Unwrap(Task`1<Task`1<TResult>> task);

public class TaskFactory	public class TaskFactory
public CancellationToken CancellationToken { get; }	public CancellationToken CancellationToken { get; }
public TaskContinuationOptions ContinuationOptions { get; }	public TaskContinuationOptions ContinuationOptions { get; }
public TaskCreationOptions CreationOptions { get; }	public TaskCreationOptions CreationOptions { get; }
public TaskScheduler Scheduler { get; }	public TaskScheduler Scheduler { get; }
public Task ContinueWhenAll(Task tasks, Action`1<Task[]> continuationAction);	public Task ContinueWhenAll(Task tasks, Action`1<Task[]> continuationAction);
public Task ContinueWhenAll(Task tasks, Action`1<Task[]> continuationAction, CancellationToken cancellationToken);	public Task ContinueWhenAll(Task tasks, Action`1<Task[]> continuationAction, CancellationToken cancellationToken);
public Task ContinueWhenAll(Task tasks, Action`1<Task[]> continuationAction, TaskContinuationOptions continuationOptions);	public Task ContinueWhenAll(Task tasks, Action`1<Task[]> continuationAction, TaskContinuationOptions continuationOptions);
public Task ContinueWhenAll(Task tasks, Action`1<Task[]> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);	public Task ContinueWhenAll(Task tasks, Action`1<Task[]> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
public Task ContinueWhenAll(Task`1 tasks, Action`1<Task`1[]> continuationAction);	public Task ContinueWhenAll(Task`1 tasks, Action`1<Task`1[]> continuationAction);
public Task ContinueWhenAll(Task`1 tasks, Action`1<Task`1[]> continuationAction, CancellationToken cancellationToken);	public Task ContinueWhenAll(Task`1 tasks, Action`1<Task`1[]> continuationAction, CancellationToken cancellationToken);
public Task ContinueWhenAll(Task`1 tasks, Action`1<Task`1[]> continuationAction, TaskContinuationOptions continuationOptions);	public Task ContinueWhenAll(Task`1 tasks, Action`1<Task`1[]> continuationAction, TaskContinuationOptions continuationOptions);
public Task ContinueWhenAll(Task`1 tasks, Action`1<Task`1[]> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);	public Task ContinueWhenAll(Task`1 tasks, Action`1<Task`1[]> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
public Task`1<TResult> ContinueWhenAll(Task tasks, Func`2<Task[], TResult> continuationFunction);	public Task`1<TResult> ContinueWhenAll(Task tasks, Func`2<Task[], TResult> continuationFunction);
public Task`1<TResult> ContinueWhenAll(Task tasks, Func`2<Task[], TResult> continuationFunction, CancellationToken cancellationToken);	public Task`1<TResult> ContinueWhenAll(Task tasks, Func`2<Task[], TResult> continuationFunction, CancellationToken cancellationToken);
public Task`1<TResult> ContinueWhenAll(Task tasks, Func`2<Task[], TResult> continuationFunction, TaskContinuationOptions continuationOptions);	public Task`1<TResult> ContinueWhenAll(Task tasks, Func`2<Task[], TResult> continuationFunction, TaskContinuationOptions continuationOptions);
public Task`1<TResult> ContinueWhenAll(Task tasks, Func`2<Task[], TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);	public Task`1<TResult> ContinueWhenAll(Task tasks, Func`2<Task[], TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
public Task`1<TResult> ContinueWhenAll(Task`1 tasks, Func`2<Task`1[], TResult> continuationFunction);	public Task`1<TResult> ContinueWhenAll(Task`1 tasks, Func`2<Task`1[], TResult> continuationFunction);
public Task`1<TResult> ContinueWhenAll(Task`1 tasks, Func`2<Task`1[], TResult> continuationFunction, CancellationToken cancellationToken);	public Task`1<TResult> ContinueWhenAll(Task`1 tasks, Func`2<Task`1[], TResult> continuationFunction, CancellationToken cancellationToken);
public Task`1<TResult> ContinueWhenAll(Task`1 tasks, Func`2<Task`1[], TResult> continuationFunction, TaskContinuationOptions continuationOptions);	public Task`1<TResult> ContinueWhenAll(Task`1 tasks, Func`2<Task`1[], TResult> continuationFunction, TaskContinuationOptions continuationOptions);
public Task`1<TResult> ContinueWhenAll(Task`1 tasks, Func`2<Task`1[], TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);	public Task`1<TResult> ContinueWhenAll(Task`1 tasks, Func`2<Task`1[], TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
public Task ContinueWhenAny(Task tasks, Action`1<Task> continuationAction);	public Task ContinueWhenAny(Task tasks, Action`1<Task> continuationAction);
public Task ContinueWhenAny(Task tasks, Action`1<Task> continuationAction, CancellationToken cancellationToken);	public Task ContinueWhenAny(Task tasks, Action`1<Task> continuationAction, CancellationToken cancellationToken);
public Task ContinueWhenAny(Task tasks, Action`1<Task> continuationAction, TaskContinuationOptions continuationOptions);	public Task ContinueWhenAny(Task tasks, Action`1<Task> continuationAction, TaskContinuationOptions continuationOptions);
public Task ContinueWhenAny(Task tasks, Action`1<Task> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);	public Task ContinueWhenAny(Task tasks, Action`1<Task> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
public Task`1<TResult> ContinueWhenAny(Task tasks, Func`2<Task, TResult> continuationFunction);	public Task`1<TResult> ContinueWhenAny(Task tasks, Func`2<Task, TResult> continuationFunction);
public Task`1<TResult> ContinueWhenAny(Task tasks, Func`2<Task, TResult> continuationFunction, CancellationToken cancellationToken);	public Task`1<TResult> ContinueWhenAny(Task tasks, Func`2<Task, TResult> continuationFunction, CancellationToken cancellationToken);
public Task`1<TResult> ContinueWhenAny(Task tasks, Func`2<Task, TResult> continuationFunction, TaskContinuationOptions continuationOptions);	public Task`1<TResult> ContinueWhenAny(Task tasks, Func`2<Task, TResult> continuationFunction, TaskContinuationOptions continuationOptions);
public Task`1<TResult> ContinueWhenAny(Task tasks, Func`2<Task, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);	public Task`1<TResult> ContinueWhenAny(Task tasks, Func`2<Task, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
public Task`1<TResult> ContinueWhenAny(Task`1 tasks, Func`2<Task`1<TAntecedentResult>, TResult> continuationFunction);	public Task`1<TResult> ContinueWhenAny(Task`1 tasks, Func`2<Task`1<TAntecedentResult>, TResult> continuationFunction);
public Task`1<TResult> ContinueWhenAny(Task`1 tasks, Func`2<Task`1<TAntecedentResult>, TResult> continuationFunction, CancellationToken cancellationToken);	public Task`1<TResult> ContinueWhenAny(Task`1 tasks, Func`2<Task`1<TAntecedentResult>, TResult> continuationFunction, CancellationToken cancellationToken);
public Task`1<TResult> ContinueWhenAny(Task`1 tasks, Func`2<Task`1<TAntecedentResult>, TResult> continuationFunction, TaskContinuationOptions continuationOptions);	public Task`1<TResult> ContinueWhenAny(Task`1 tasks, Func`2<Task`1<TAntecedentResult>, TResult> continuationFunction, TaskContinuationOptions continuationOptions);
public Task`1<TResult> ContinueWhenAny(Task`1 tasks, Func`2<Task`1<TAntecedentResult>, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);	public Task`1<TResult> ContinueWhenAny(Task`1 tasks, Func`2<Task`1<TAntecedentResult>, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
public Task ContinueWhenAny(Task`1 tasks, Action`1<Task`1<TAntecedentResult>> continuationAction);	public Task ContinueWhenAny(Task`1 tasks, Action`1<Task`1<TAntecedentResult>> continuationAction);
public Task ContinueWhenAny(Task`1 tasks, Action`1<Task`1<TAntecedentResult>> continuationAction, CancellationToken cancellationToken);	public Task ContinueWhenAny(Task`1 tasks, Action`1<Task`1<TAntecedentResult>> continuationAction, CancellationToken cancellationToken);
public Task ContinueWhenAny(Task`1 tasks, Action`1<Task`1<TAntecedentResult>> continuationAction, TaskContinuationOptions continuationOptions);	public Task ContinueWhenAny(Task`1 tasks, Action`1<Task`1<TAntecedentResult>> continuationAction, TaskContinuationOptions continuationOptions);
public Task ContinueWhenAny(Task`1 tasks, Action`1<Task`1<TAntecedentResult>> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);	public Task ContinueWhenAny(Task`1 tasks, Action`1<Task`1<TAntecedentResult>> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
public Task FromAsync(IAsyncResult asyncResult, Action`1<IAsyncResult> endMethod);	public Task FromAsync(IAsyncResult asyncResult, Action`1<IAsyncResult> endMethod);
public Task FromAsync(IAsyncResult asyncResult, Action`1<IAsyncResult> endMethod, TaskCreationOptions creationOptions);	public Task FromAsync(IAsyncResult asyncResult, Action`1<IAsyncResult> endMethod, TaskCreationOptions creationOptions);
public Task FromAsync(IAsyncResult asyncResult, Action`1<IAsyncResult> endMethod, TaskCreationOptions creationOptions, TaskScheduler scheduler);	public Task FromAsync(IAsyncResult asyncResult, Action`1<IAsyncResult> endMethod, TaskCreationOptions creationOptions, TaskScheduler scheduler);
public Task FromAsync(Func`3<AsyncCallback, Object, IAsyncResult> beginMethod, Action`1<IAsyncResult> endMethod, Object state);	public Task FromAsync(Func`3<AsyncCallback, Object, IAsyncResult> beginMethod, Action`1<IAsyncResult> endMethod, Object state);
public Task FromAsync(Func`3<AsyncCallback, Object, IAsyncResult> beginMethod, Action`1<IAsyncResult> endMethod, Object state, TaskCreationOptions creationOptions);	public Task FromAsync(Func`3<AsyncCallback, Object, IAsyncResult> beginMethod, Action`1<IAsyncResult> endMethod, Object state, TaskCreationOptions creationOptions);
public Task FromAsync(Func`4<TArg1, AsyncCallback, Object, IAsyncResult> beginMethod, Action`1<IAsyncResult> endMethod, TArg1 arg1, Object state);	public Task FromAsync(Func`4<TArg1, AsyncCallback, Object, IAsyncResult> beginMethod, Action`1<IAsyncResult> endMethod, TArg1 arg1, Object state);
public Task FromAsync(Func`4<TArg1, AsyncCallback, Object, IAsyncResult> beginMethod, Action`1<IAsyncResult> endMethod, TArg1 arg1, Object state, TaskCreationOptions creationOptions);	public Task FromAsync(Func`4<TArg1, AsyncCallback, Object, IAsyncResult> beginMethod, Action`1<IAsyncResult> endMethod, TArg1 arg1, Object state, TaskCreationOptions creationOptions);
public Task FromAsync(Func`5<TArg1, TArg2, AsyncCallback, Object, IAsyncResult> beginMethod, Action`1<IAsyncResult> endMethod, TArg1 arg1, TArg2 arg2, Object state);	public Task FromAsync(Func`5<TArg1, TArg2, AsyncCallback, Object, IAsyncResult> beginMethod, Action`1<IAsyncResult> endMethod, TArg1 arg1, TArg2 arg2, Object state);
public Task FromAsync(Func`5<TArg1, TArg2, AsyncCallback, Object, IAsyncResult> beginMethod, Action`1<IAsyncResult> endMethod, TArg1 arg1, TArg2 arg2, Object state, TaskCreationOptions creationOptions);	public Task FromAsync(Func`5<TArg1, TArg2, AsyncCallback, Object, IAsyncResult> beginMethod, Action`1<IAsyncResult> endMethod, TArg1 arg1, TArg2 arg2, Object state, TaskCreationOptions creationOptions);
public Task FromAsync(Func`6<TArg1, TArg2, TArg3, AsyncCallback, Object, IAsyncResult> beginMethod, Action`1<IAsyncResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, Object state);	public Task FromAsync(Func`6<TArg1, TArg2, TArg3, AsyncCallback, Object, IAsyncResult> beginMethod, Action`1<IAsyncResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, Object state);
public Task FromAsync(Func`6<TArg1, TArg2, TArg3, AsyncCallback, Object, IAsyncResult> beginMethod, Action`1<IAsyncResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, Object state, TaskCreationOptions creationOptions);	public Task FromAsync(Func`6<TArg1, TArg2, TArg3, AsyncCallback, Object, IAsyncResult> beginMethod, Action`1<IAsyncResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, Object state, TaskCreationOptions creationOptions);
public Task`1<TResult> FromAsync(IAsyncResult asyncResult, Func`2<IAsyncResult, TResult> endMethod);	public Task`1<TResult> FromAsync(IAsyncResult asyncResult, Func`2<IAsyncResult, TResult> endMethod);
public Task`1<TResult> FromAsync(IAsyncResult asyncResult, Func`2<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions);	public Task`1<TResult> FromAsync(IAsyncResult asyncResult, Func`2<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions);
public Task`1<TResult> FromAsync(IAsyncResult asyncResult, Func`2<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions, TaskScheduler scheduler);	public Task`1<TResult> FromAsync(IAsyncResult asyncResult, Func`2<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions, TaskScheduler scheduler);
public Task`1<TResult> FromAsync(Func`3<AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, Object state);	public Task`1<TResult> FromAsync(Func`3<AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, Object state);
public Task`1<TResult> FromAsync(Func`3<AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, Object state, TaskCreationOptions creationOptions);	public Task`1<TResult> FromAsync(Func`3<AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, Object state, TaskCreationOptions creationOptions);
public Task`1<TResult> FromAsync(Func`4<TArg1, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, Object state);	public Task`1<TResult> FromAsync(Func`4<TArg1, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, Object state);
public Task`1<TResult> FromAsync(Func`4<TArg1, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, Object state, TaskCreationOptions creationOptions);	public Task`1<TResult> FromAsync(Func`4<TArg1, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, Object state, TaskCreationOptions creationOptions);
public Task`1<TResult> FromAsync(Func`5<TArg1, TArg2, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, Object state);	public Task`1<TResult> FromAsync(Func`5<TArg1, TArg2, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, Object state);
public Task`1<TResult> FromAsync(Func`5<TArg1, TArg2, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, Object state, TaskCreationOptions creationOptions);	public Task`1<TResult> FromAsync(Func`5<TArg1, TArg2, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, Object state, TaskCreationOptions creationOptions);
public Task`1<TResult> FromAsync(Func`6<TArg1, TArg2, TArg3, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, Object state);	public Task`1<TResult> FromAsync(Func`6<TArg1, TArg2, TArg3, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, Object state);
public Task`1<TResult> FromAsync(Func`6<TArg1, TArg2, TArg3, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, Object state, TaskCreationOptions creationOptions);	public Task`1<TResult> FromAsync(Func`6<TArg1, TArg2, TArg3, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, Object state, TaskCreationOptions creationOptions);
public Task StartNew(Action action);	public Task StartNew(Action action);
public Task StartNew(Action action, CancellationToken cancellationToken);	public Task StartNew(Action action, CancellationToken cancellationToken);
public Task StartNew(Action action, TaskCreationOptions creationOptions);	public Task StartNew(Action action, TaskCreationOptions creationOptions);
public Task StartNew(Action action, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler);	public Task StartNew(Action action, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler);
public Task StartNew(Action`1<Object> action, Object state);	public Task StartNew(Action`1<Object> action, Object state);
public Task StartNew(Action`1<Object> action, Object state, CancellationToken cancellationToken);	public Task StartNew(Action`1<Object> action, Object state, CancellationToken cancellationToken);
public Task StartNew(Action`1<Object> action, Object state, TaskCreationOptions creationOptions);	public Task StartNew(Action`1<Object> action, Object state, TaskCreationOptions creationOptions);
public Task StartNew(Action`1<Object> action, Object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler);	public Task StartNew(Action`1<Object> action, Object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler);
public Task`1<TResult> StartNew(Func`1<TResult> function);	public Task`1<TResult> StartNew(Func`1<TResult> function);
public Task`1<TResult> StartNew(Func`1<TResult> function, CancellationToken cancellationToken);	public Task`1<TResult> StartNew(Func`1<TResult> function, CancellationToken cancellationToken);
public Task`1<TResult> StartNew(Func`1<TResult> function, TaskCreationOptions creationOptions);	public Task`1<TResult> StartNew(Func`1<TResult> function, TaskCreationOptions creationOptions);
public Task`1<TResult> StartNew(Func`1<TResult> function, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler);	public Task`1<TResult> StartNew(Func`1<TResult> function, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler);
public Task`1<TResult> StartNew(Func`2<Object, TResult> function, Object state);	public Task`1<TResult> StartNew(Func`2<Object, TResult> function, Object state);
public Task`1<TResult> StartNew(Func`2<Object, TResult> function, Object state, CancellationToken cancellationToken);	public Task`1<TResult> StartNew(Func`2<Object, TResult> function, Object state, CancellationToken cancellationToken);
public Task`1<TResult> StartNew(Func`2<Object, TResult> function, Object state, TaskCreationOptions creationOptions);	public Task`1<TResult> StartNew(Func`2<Object, TResult> function, Object state, TaskCreationOptions creationOptions);
public Task`1<TResult> StartNew(Func`2<Object, TResult> function, Object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler);	public Task`1<TResult> StartNew(Func`2<Object, TResult> function, Object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler);

public class TaskFactory`1<TResult>	public class TaskFactory`1<TResult>
public CancellationToken CancellationToken { get; }	public CancellationToken CancellationToken { get; }
public TaskContinuationOptions ContinuationOptions { get; }	public TaskContinuationOptions ContinuationOptions { get; }
public TaskCreationOptions CreationOptions { get; }	public TaskCreationOptions CreationOptions { get; }
public TaskScheduler Scheduler { get; }	public TaskScheduler Scheduler { get; }
public Task`1<TResult> ContinueWhenAll(Task tasks, Func`2<Task[], TResult> continuationFunction);	public Task`1<TResult> ContinueWhenAll(Task tasks, Func`2<Task[], TResult> continuationFunction);
public Task`1<TResult> ContinueWhenAll(Task tasks, Func`2<Task[], TResult> continuationFunction, CancellationToken cancellationToken);	public Task`1<TResult> ContinueWhenAll(Task tasks, Func`2<Task[], TResult> continuationFunction, CancellationToken cancellationToken);
public Task`1<TResult> ContinueWhenAll(Task tasks, Func`2<Task[], TResult> continuationFunction, TaskContinuationOptions continuationOptions);	public Task`1<TResult> ContinueWhenAll(Task tasks, Func`2<Task[], TResult> continuationFunction, TaskContinuationOptions continuationOptions);
public Task`1<TResult> ContinueWhenAll(Task tasks, Func`2<Task[], TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);	public Task`1<TResult> ContinueWhenAll(Task tasks, Func`2<Task[], TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
public Task`1<TResult> ContinueWhenAll(Task`1 tasks, Func`2<Task`1[], TResult> continuationFunction);	public Task`1<TResult> ContinueWhenAll(Task`1 tasks, Func`2<Task`1[], TResult> continuationFunction);
public Task`1<TResult> ContinueWhenAll(Task`1 tasks, Func`2<Task`1[], TResult> continuationFunction, CancellationToken cancellationToken);	public Task`1<TResult> ContinueWhenAll(Task`1 tasks, Func`2<Task`1[], TResult> continuationFunction, CancellationToken cancellationToken);
public Task`1<TResult> ContinueWhenAll(Task`1 tasks, Func`2<Task`1[], TResult> continuationFunction, TaskContinuationOptions continuationOptions);	public Task`1<TResult> ContinueWhenAll(Task`1 tasks, Func`2<Task`1[], TResult> continuationFunction, TaskContinuationOptions continuationOptions);
public Task`1<TResult> ContinueWhenAll(Task`1 tasks, Func`2<Task`1[], TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);	public Task`1<TResult> ContinueWhenAll(Task`1 tasks, Func`2<Task`1[], TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
public Task`1<TResult> ContinueWhenAny(Task tasks, Func`2<Task, TResult> continuationFunction);	public Task`1<TResult> ContinueWhenAny(Task tasks, Func`2<Task, TResult> continuationFunction);
public Task`1<TResult> ContinueWhenAny(Task tasks, Func`2<Task, TResult> continuationFunction, CancellationToken cancellationToken);	public Task`1<TResult> ContinueWhenAny(Task tasks, Func`2<Task, TResult> continuationFunction, CancellationToken cancellationToken);
public Task`1<TResult> ContinueWhenAny(Task tasks, Func`2<Task, TResult> continuationFunction, TaskContinuationOptions continuationOptions);	public Task`1<TResult> ContinueWhenAny(Task tasks, Func`2<Task, TResult> continuationFunction, TaskContinuationOptions continuationOptions);
public Task`1<TResult> ContinueWhenAny(Task tasks, Func`2<Task, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);	public Task`1<TResult> ContinueWhenAny(Task tasks, Func`2<Task, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
public Task`1<TResult> ContinueWhenAny(Task`1 tasks, Func`2<Task`1<TAntecedentResult>, TResult> continuationFunction);	public Task`1<TResult> ContinueWhenAny(Task`1 tasks, Func`2<Task`1<TAntecedentResult>, TResult> continuationFunction);
public Task`1<TResult> ContinueWhenAny(Task`1 tasks, Func`2<Task`1<TAntecedentResult>, TResult> continuationFunction, CancellationToken cancellationToken);	public Task`1<TResult> ContinueWhenAny(Task`1 tasks, Func`2<Task`1<TAntecedentResult>, TResult> continuationFunction, CancellationToken cancellationToken);
public Task`1<TResult> ContinueWhenAny(Task`1 tasks, Func`2<Task`1<TAntecedentResult>, TResult> continuationFunction, TaskContinuationOptions continuationOptions);	public Task`1<TResult> ContinueWhenAny(Task`1 tasks, Func`2<Task`1<TAntecedentResult>, TResult> continuationFunction, TaskContinuationOptions continuationOptions);
public Task`1<TResult> ContinueWhenAny(Task`1 tasks, Func`2<Task`1<TAntecedentResult>, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);	public Task`1<TResult> ContinueWhenAny(Task`1 tasks, Func`2<Task`1<TAntecedentResult>, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler);
public Task`1<TResult> FromAsync(IAsyncResult asyncResult, Func`2<IAsyncResult, TResult> endMethod);	public Task`1<TResult> FromAsync(IAsyncResult asyncResult, Func`2<IAsyncResult, TResult> endMethod);
public Task`1<TResult> FromAsync(IAsyncResult asyncResult, Func`2<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions);	public Task`1<TResult> FromAsync(IAsyncResult asyncResult, Func`2<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions);
public Task`1<TResult> FromAsync(IAsyncResult asyncResult, Func`2<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions, TaskScheduler scheduler);	public Task`1<TResult> FromAsync(IAsyncResult asyncResult, Func`2<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions, TaskScheduler scheduler);
public Task`1<TResult> FromAsync(Func`3<AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, Object state);	public Task`1<TResult> FromAsync(Func`3<AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, Object state);
public Task`1<TResult> FromAsync(Func`3<AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, Object state, TaskCreationOptions creationOptions);	public Task`1<TResult> FromAsync(Func`3<AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, Object state, TaskCreationOptions creationOptions);
public Task`1<TResult> FromAsync(Func`4<TArg1, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, Object state);	public Task`1<TResult> FromAsync(Func`4<TArg1, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, Object state);
public Task`1<TResult> FromAsync(Func`4<TArg1, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, Object state, TaskCreationOptions creationOptions);	public Task`1<TResult> FromAsync(Func`4<TArg1, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, Object state, TaskCreationOptions creationOptions);
public Task`1<TResult> FromAsync(Func`5<TArg1, TArg2, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, Object state);	public Task`1<TResult> FromAsync(Func`5<TArg1, TArg2, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, Object state);
public Task`1<TResult> FromAsync(Func`5<TArg1, TArg2, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, Object state, TaskCreationOptions creationOptions);	public Task`1<TResult> FromAsync(Func`5<TArg1, TArg2, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, Object state, TaskCreationOptions creationOptions);
public Task`1<TResult> FromAsync(Func`6<TArg1, TArg2, TArg3, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, Object state);	public Task`1<TResult> FromAsync(Func`6<TArg1, TArg2, TArg3, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, Object state);
public Task`1<TResult> FromAsync(Func`6<TArg1, TArg2, TArg3, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, Object state, TaskCreationOptions creationOptions);	public Task`1<TResult> FromAsync(Func`6<TArg1, TArg2, TArg3, AsyncCallback, Object, IAsyncResult> beginMethod, Func`2<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, Object state, TaskCreationOptions creationOptions);
public Task`1<TResult> StartNew(Func`1<TResult> function);	public Task`1<TResult> StartNew(Func`1<TResult> function);
public Task`1<TResult> StartNew(Func`1<TResult> function, CancellationToken cancellationToken);	public Task`1<TResult> StartNew(Func`1<TResult> function, CancellationToken cancellationToken);
public Task`1<TResult> StartNew(Func`1<TResult> function, TaskCreationOptions creationOptions);	public Task`1<TResult> StartNew(Func`1<TResult> function, TaskCreationOptions creationOptions);
public Task`1<TResult> StartNew(Func`1<TResult> function, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler);	public Task`1<TResult> StartNew(Func`1<TResult> function, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler);
public Task`1<TResult> StartNew(Func`2<Object, TResult> function, Object state);	public Task`1<TResult> StartNew(Func`2<Object, TResult> function, Object state);
public Task`1<TResult> StartNew(Func`2<Object, TResult> function, Object state, CancellationToken cancellationToken);	public Task`1<TResult> StartNew(Func`2<Object, TResult> function, Object state, CancellationToken cancellationToken);
public Task`1<TResult> StartNew(Func`2<Object, TResult> function, Object state, TaskCreationOptions creationOptions);	public Task`1<TResult> StartNew(Func`2<Object, TResult> function, Object state, TaskCreationOptions creationOptions);
public Task`1<TResult> StartNew(Func`2<Object, TResult> function, Object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler);	public Task`1<TResult> StartNew(Func`2<Object, TResult> function, Object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler);

	class TplEtwProvider

public abstract class TaskScheduler	public abstract class TaskScheduler
static public TaskScheduler Current { get; }	static public TaskScheduler Current { get; }
static public TaskScheduler Default { get; }	static public TaskScheduler Default { get; }
public Int32 Id { get; }	public Int32 Id { get; }
public virtual Int32 MaximumConcurrencyLevel { get; }	public virtual Int32 MaximumConcurrencyLevel { get; }
static public event EventHandler`1<UnobservedTaskExceptionEventArgs> UnobservedTaskException;	static public event EventHandler`1<UnobservedTaskExceptionEventArgs> UnobservedTaskException;
static public TaskScheduler FromCurrentSynchronizationContext();	static public TaskScheduler FromCurrentSynchronizationContext();
	protected abstract virtual IEnumerable`1<Task> GetScheduledTasks();
	internal protected abstract virtual void QueueTask(Task task);
	internal protected virtual Boolean TryDequeue(Task task);
	protected Boolean TryExecuteTask(Task task);

public class TaskSchedulerException	public class TaskSchedulerException
: Exception, _Exception	: Exception, ISerializable, _Exception

public sealed enum TaskStatus	public sealed enum TaskStatus
: IComparable, IFormattable, IConvertible	: IComparable, IFormattable, IConvertible
{ Created, WaitingForActivation, WaitingToRun, Running, WaitingForChildrenToComplete, RanToCompletion, Canceled, Faulted }	{ Created, WaitingForActivation, WaitingToRun, Running, WaitingForChildrenToComplete, RanToCompletion, Canceled, Faulted }

	sealed enum TplEtwProvider
	: IComparable, IFormattable, IConvertible
	{ Synchronous, Asynchronous }

public class UnobservedTaskExceptionEventArgs	public class UnobservedTaskExceptionEventArgs
: EventArgs	: EventArgs
public AggregateException Exception { get; }	public AggregateException Exception { get; }
public Boolean Observed { get; }	public Boolean Observed { get; }
public void SetObserved();	public void SetObserved();