How to convert between async shapes

Use these helpers at interop boundaries where one part of your code uses Async<'T> and another part uses Task, ValueTask, ColdTask, or a cancellable task shape.

I have	I need	Use
`ValueTask<'T>`	`Async<'T>`	`Async.AwaitValueTask`
`Async<'T>`	`ValueTask<'T>`	`Async.AsValueTask`
`ColdTask<'T>`	`Async<'T>`	`Async.AwaitColdTask`
`Async<'T>`	`ColdTask<'T>`	`Async.AsColdTask`
`CancellableTask<'T>`	`Async<'T>`	`Async.AwaitCancellableTask`
`Async<'T>`	`CancellableTask<'T>`	`Async.AsCancellableTask`
`CancellableValueTask<'T>`	`Async<'T>`	`Async.AwaitCancellableValueTask`
`Async<'T>`	`CancellableValueTask<'T>`	`Async.AsCancellableValueTask`
`Task<'T>` or `ValueTask<'T>`	`Async<'T>` with AsyncEx task exception behavior	`AsyncEx.AwaitTask` or `AsyncEx.AwaitValueTask`
Custom awaitable	`Async<'T>` with AsyncEx	`AsyncEx.AwaitAwaitable` or `AsyncEx.AwaitAwaiter`

Use `ValueTask` from `Async`

Use Async.AwaitValueTask when an async { } workflow needs to await a ValueTask<'T> or ValueTask. Use Async.AsValueTask when an Async<'T> must be exposed to a ValueTask<'T> caller.

let getCachedValue () = ValueTask<int> 42

let valueTaskInsideAsync =
    async {
        let! value =
            getCachedValue ()
            |> Async.AwaitValueTask

        return value + 1
    }

let asyncExposedAsValueTask =
    valueTaskInsideAsync
    |> Async.AsValueTask

Use `ColdTask` from `Async`

Use Async.AwaitColdTask when an async { } workflow needs to start and await cold task-shaped work. Use Async.AsColdTask when an Async<'T> should be exposed as unit -> Task<'T>.

let loadCold: ColdTask<int> = coldTask { return 10 }

let coldTaskInsideAsync =
    async {
        let! value =
            loadCold
            |> Async.AwaitColdTask

        return value * 2
    }

let asyncExposedAsColdTask =
    coldTaskInsideAsync
    |> Async.AsColdTask

Use cancellable task shapes from `Async`

Use Async.AwaitCancellableTask or Async.AwaitCancellableValueTask when the surrounding Async<'T> should provide the cancellation token. The helper reads Async.CancellationToken and passes it into the cancellable operation.

let loadCancellableTask: CancellableTask<int> =
    cancellableTask {
        let! ct = CancellableTask.getCancellationToken ()
        do! Task.Delay(1, ct)
        return 20
    }

let loadCancellableValueTask: CancellableValueTask<int> =
    cancellableValueTask {
        let! ct = CancellableValueTask.getCancellationToken ()
        do! Task.Delay(1, ct)
        return 30
    }

let cancellableTaskInsideAsync =
    async {
        let! value =
            loadCancellableTask
            |> Async.AwaitCancellableTask

        return value + 1
    }

let cancellableValueTaskInsideAsync =
    async {
        let! value =
            loadCancellableValueTask
            |> Async.AwaitCancellableValueTask

        return value + 1
    }

Expose `Async` as a cancellable task shape

Use Async.AsCancellableTask or Async.AsCancellableValueTask when a caller should provide a token later. The returned function starts the original Async<'T> with the supplied token.

let loadFromAsync =
    async {
        let! ct = Async.CancellationToken
        do! Async.Sleep 1
        ct.ThrowIfCancellationRequested()
        return 40
    }

let asyncExposedAsCancellableTask =
    loadFromAsync
    |> Async.AsCancellableTask

let asyncExposedAsCancellableValueTask =
    loadFromAsync
    |> Async.AsCancellableValueTask

Use AsyncEx for Task, ValueTask, and custom awaitables

AsyncEx provides await helpers with task exception behavior intended for IcedTasks interop. In most code, the asyncEx { } builder can bind these values directly. Use the static helpers when you want an explicit conversion.

let taskInsideAsyncEx =
    Task.FromResult 50
    |> AsyncEx.AwaitTask

let valueTaskInsideAsyncEx =
    ValueTask<int> 60
    |> AsyncEx.AwaitValueTask

let yieldInsideAsyncEx =
    Task.Yield()
    |> AsyncEx.AwaitAwaitable

type ImmediateAwaiter<'T>(value: 'T) =
    member _.IsCompleted = true
    member _.GetResult() = value
    member _.OnCompleted(_continuation: System.Action) = ()
    member _.UnsafeOnCompleted(_continuation: System.Action) = ()

    interface INotifyCompletion with
        member this.OnCompleted(continuation) = this.OnCompleted(continuation)

    interface ICriticalNotifyCompletion with
        member this.UnsafeOnCompleted(continuation) = this.UnsafeOnCompleted(continuation)

let customAwaiterInsideAsyncEx =
    ImmediateAwaiter 70
    |> AsyncEx.AwaitAwaiter

Run the samples

These calls are here so the examples are checked as complete executable code.

let result1 =
    valueTaskInsideAsync
    |> Async.RunSynchronously

let result2 = asyncExposedAsValueTask.AsTask().GetAwaiter().GetResult()

let result3 =
    coldTaskInsideAsync
    |> Async.RunSynchronously

let result4 = asyncExposedAsColdTask().GetAwaiter().GetResult()

let result5 =
    cancellableTaskInsideAsync
    |> Async.RunSynchronously

let result6 =
    cancellableValueTaskInsideAsync
    |> Async.RunSynchronously

let result7 =
    asyncExposedAsCancellableTask CancellationToken.None
    |> Async.AwaitTask
    |> Async.RunSynchronously

let result8 =
    asyncExposedAsCancellableValueTask CancellationToken.None
    |> Async.AwaitValueTask
    |> Async.RunSynchronously

let result9 =
    taskInsideAsyncEx
    |> Async.RunSynchronously

let result10 =
    valueTaskInsideAsyncEx
    |> Async.RunSynchronously

let result11 =
    yieldInsideAsyncEx
    |> Async.RunSynchronously

let result12 =
    customAwaiterInsideAsyncEx
    |> Async.RunSynchronously

Prefer builders inside one async shape

Do not convert just to convert. If all of the code can live naturally inside one builder, keep it there. Use the conversion helpers at API boundaries, when integrating with existing libraries, or when moving gradually between async shapes.

namespace System

namespace System.Runtime

namespace System.Runtime.CompilerServices

namespace System.Threading

namespace System.Threading.Tasks

namespace IcedTasks

namespace IcedTasks.AsyncEx

val getCachedValue: unit -> ValueTask<int>

Multiple items
[<Struct>] type ValueTask = new: source: IValueTaskSource * token: int16 -> unit + 1 overload member AsTask: unit -> Task member ConfigureAwait: continueOnCapturedContext: bool -> ConfiguredValueTaskAwaitable member Equals: obj: obj -> bool + 1 overload member GetAwaiter: unit -> ValueTaskAwaiter member GetHashCode: unit -> int member Preserve: unit -> ValueTask static member (<>) : left: ValueTask * right: ValueTask -> bool static member (=) : left: ValueTask * right: ValueTask -> bool static member FromCanceled: cancellationToken: CancellationToken -> ValueTask + 1 overload ...
<summary>Provides an awaitable result of an asynchronous operation.</summary>

--------------------
[<Struct>] type ValueTask<'TResult> = new: source: IValueTaskSource<'TResult> * token: int16 -> unit + 2 overloads member AsTask: unit -> Task<'TResult> member ConfigureAwait: continueOnCapturedContext: bool -> ConfiguredValueTaskAwaitable<'TResult> member Equals: obj: obj -> bool + 1 overload member GetAwaiter: unit -> ValueTaskAwaiter<'TResult> member GetHashCode: unit -> int member Preserve: unit -> ValueTask<'TResult> member ToString: unit -> string static member (<>) : left: ValueTask<'TResult> * right: ValueTask<'TResult> -> bool static member (=) : left: ValueTask<'TResult> * right: ValueTask<'TResult> -> bool ...
<summary>Provides a value type that wraps a <see cref="T:System.Threading.Tasks.Task`1" /> and a <typeparamref name="TResult" />, only one of which is used.</summary>
<typeparam name="TResult">The result.</typeparam>

--------------------
ValueTask ()
ValueTask(task: Task) : ValueTask
ValueTask(source: Sources.IValueTaskSource, token: int16) : ValueTask

--------------------
ValueTask ()
ValueTask(task: Task<'TResult>) : ValueTask<'TResult>
ValueTask(result: 'TResult) : ValueTask<'TResult>
ValueTask(source: Sources.IValueTaskSource<'TResult>, token: int16) : ValueTask<'TResult>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

val valueTaskInsideAsync: Async<int>

val async: AsyncBuilder

val value: int

Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>

static member Async.AwaitValueTask: vTask: ValueTask<'a> -> Async<'a>
static member Async.AwaitValueTask: vTask: ValueTask -> Async<unit>

val asyncExposedAsValueTask: ValueTask<int>

static member Async.AsValueTask: computation: Async<'T> -> ValueTask<'T>

val loadCold: ColdTask<int>

Multiple items
module ColdTask from IcedTasks.ColdTasks.ColdTasks
<summary> Contains functional helper functions for composing and converting ColdTask values. </summary>

--------------------
type ColdTask = unit -> Task
<summary> unit -> Task </summary>

--------------------
type ColdTask<'T> = unit -> Task<'T>
<summary> unit -> Task<'T> </summary>

val coldTask: ColdTaskBuilder
<summary> Builds a coldTask using computation expression syntax. </summary>

val coldTaskInsideAsync: Async<int>

static member Async.AwaitColdTask: t: ColdTask<'T> -> Async<'T>
static member Async.AwaitColdTask: t: ColdTask -> Async<unit>

val asyncExposedAsColdTask: ColdTask<int>

static member Async.AsColdTask: computation: Async<'T> -> ColdTask<'T>

val loadCancellableTask: CancellableTask<int>

Multiple items
module CancellableTask from IcedTasks.CancellableTasks.CancellableTasks
<summary> Contains functional helper functions for composing and converting CancellableTask values. </summary>

--------------------
type CancellableTask = CancellationToken -> Task
<summary> CancellationToken -> Task </summary>

--------------------
type CancellableTask<'T> = CancellationToken -> Task<'T>
<summary> CancellationToken -> Task<'T> </summary>

val cancellableTask: CancellableTaskBuilder
<summary> Builds a cancellableTask using computation expression syntax. </summary>

val ct: CancellationToken

val getCancellationToken: unit -> ct: CancellationToken -> ValueTask<CancellationToken>
<summary>Gets the default cancellation token for executing computations.</summary>
<returns>The default CancellationToken.</returns>
<category index="3">Cancellation and Exceptions</category>
<example id="default-cancellation-token-1"><code lang="F#"> use tokenSource = new CancellationTokenSource() let primes = [ 2; 3; 5; 7; 11 ] for i in primes do let computation = cancellableTask { let! cancellationToken = CancellableTask.getCancellationToken() do! Task.Delay(i * 1000, cancellationToken) printfn $"{i}" } computation tokenSource.Token |> ignore Thread.Sleep(6000) tokenSource.Cancel() printfn "Tasks Finished" </code> This will print "2" 2 seconds from start, "3" 3 seconds from start, "5" 5 seconds from start, cease computation and then followed by "Tasks Finished". </example>

Multiple items
type Task = interface IAsyncResult interface IDisposable new: action: Action -> unit + 7 overloads member ConfigureAwait: continueOnCapturedContext: bool -> ConfiguredTaskAwaitable + 1 overload member ContinueWith: continuationAction: Action<Task,obj> * state: obj -> Task + 19 overloads member Dispose: unit -> unit member GetAwaiter: unit -> TaskAwaiter member RunSynchronously: unit -> unit + 1 overload member Start: unit -> unit + 1 overload member Wait: unit -> unit + 5 overloads ...
<summary>Represents an asynchronous operation.</summary>

--------------------
type Task<'TResult> = inherit Task new: ``function`` : Func<obj,'TResult> * state: obj -> unit + 7 overloads member ConfigureAwait: continueOnCapturedContext: bool -> ConfiguredTaskAwaitable<'TResult> + 1 overload member ContinueWith: continuationAction: Action<Task<'TResult>,obj> * state: obj -> Task + 19 overloads member GetAwaiter: unit -> TaskAwaiter<'TResult> member WaitAsync: cancellationToken: CancellationToken -> Task<'TResult> + 4 overloads member Result: 'TResult static member Factory: TaskFactory<'TResult>
<summary>Represents an asynchronous operation that can return a value.</summary>
<typeparam name="TResult">The type of the result produced by this <see cref="T:System.Threading.Tasks.Task`1" />.</typeparam>

--------------------
Task(action: System.Action) : Task
Task(action: System.Action, cancellationToken: CancellationToken) : Task
Task(action: System.Action, creationOptions: TaskCreationOptions) : Task
Task(action: System.Action<obj>, state: obj) : Task
Task(action: System.Action, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions) : Task
Task(action: System.Action<obj>, state: obj, cancellationToken: CancellationToken) : Task
Task(action: System.Action<obj>, state: obj, creationOptions: TaskCreationOptions) : Task
Task(action: System.Action<obj>, state: obj, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions) : Task

--------------------
Task(``function`` : System.Func<'TResult>) : Task<'TResult>
Task(``function`` : System.Func<obj,'TResult>, state: obj) : Task<'TResult>
Task(``function`` : System.Func<'TResult>, cancellationToken: CancellationToken) : Task<'TResult>
Task(``function`` : System.Func<'TResult>, creationOptions: TaskCreationOptions) : Task<'TResult>
Task(``function`` : System.Func<obj,'TResult>, state: obj, cancellationToken: CancellationToken) : Task<'TResult>
Task(``function`` : System.Func<obj,'TResult>, state: obj, creationOptions: TaskCreationOptions) : Task<'TResult>
Task(``function`` : System.Func<'TResult>, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions) : Task<'TResult>
Task(``function`` : System.Func<obj,'TResult>, state: obj, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions) : Task<'TResult>

Task.Delay(delay: System.TimeSpan) : Task
Task.Delay(millisecondsDelay: int) : Task
Task.Delay(delay: System.TimeSpan, timeProvider: System.TimeProvider) : Task
Task.Delay(delay: System.TimeSpan, cancellationToken: CancellationToken) : Task
Task.Delay(millisecondsDelay: int, cancellationToken: CancellationToken) : Task
Task.Delay(delay: System.TimeSpan, timeProvider: System.TimeProvider, cancellationToken: CancellationToken) : Task

val loadCancellableValueTask: CancellableValueTask<int>

Multiple items
module CancellableValueTask from IcedTasks.CancellablePoolingValueTasks.CancellablePoolingValueTasks
<summary> Contains functional helper functions for composing and converting pooling-backed CancellableValueTask values. </summary>

--------------------
module CancellableValueTask from IcedTasks.CancellableValueTasks.CancellableValueTasks
<summary> Contains functional helper functions for composing and converting CancellableValueTask values. </summary>

--------------------
type CancellableValueTask = CancellationToken -> ValueTask
<summary> CancellationToken -> ValueTask </summary>

--------------------
type CancellableValueTask<'T> = CancellationToken -> ValueTask<'T>
<summary> CancellationToken -> ValueTask<'T> </summary>

val cancellableValueTask: CancellableValueTaskBuilder
<summary> Builds a cancellableValueTask using computation expression syntax. This utilizes <see cref="T:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1">System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder</see></summary>
<remarks> Instead of needing an attribute the compiler needs to know about like in <see href="https://github.com/dotnet/runtime/issues/49903">dotnet/runtime/issues/49903</see> this is a specific computation expression. </remarks>

Multiple items
val getCancellationToken: unit -> ct: CancellationToken -> ValueTask<CancellationToken>
<summary>Gets the default cancellation token for executing computations.</summary>
<returns>The default CancellationToken.</returns>
<category index="3">Cancellation and Exceptions</category>
<example id="default-cancellation-token-1"><code lang="F#"> use tokenSource = new CancellationTokenSource() let primes = [ 2; 3; 5; 7; 11 ] for i in primes do let computation = cancellableValueTask { let! cancellationToken = CancellableValueTask.getCancellationToken() do! Task.Delay(i * 1000, cancellationToken) printfn $"{i}" } computation tokenSource.Token |> ignore Thread.Sleep(6000) tokenSource.Cancel() printfn "Tasks Finished" </code> This will print "2" 2 seconds from start, "3" 3 seconds from start, "5" 5 seconds from start, cease computation and then followed by "Tasks Finished". </example>

--------------------
val getCancellationToken: unit -> ct: CancellationToken -> ValueTask<CancellationToken>
<summary>Gets the default cancellation token for executing computations.</summary>
<returns>The default CancellationToken.</returns>
<category index="3">Cancellation and Exceptions</category>
<example id="default-cancellation-token-1"><code lang="F#"> use tokenSource = new CancellationTokenSource() let primes = [ 2; 3; 5; 7; 11 ] for i in primes do let computation = cancellableValueTask { let! cancellationToken = CancellableValueTask.getCancellationToken() do! Task.Delay(i * 1000, cancellationToken) printfn $"{i}" } computation tokenSource.Token |> ignore Thread.Sleep(6000) tokenSource.Cancel() printfn "Tasks Finished" </code> This will print "2" 2 seconds from start, "3" 3 seconds from start, "5" 5 seconds from start, cease computation and then followed by "Tasks Finished". </example>

val cancellableTaskInsideAsync: Async<int>

static member Async.AwaitCancellableTask: [<InlineIfLambda>] t: (CancellationToken -> Task<'T>) -> Async<'T>
static member Async.AwaitCancellableTask: [<InlineIfLambda>] t: (CancellationToken -> Task) -> Async<unit>

val cancellableValueTaskInsideAsync: Async<int>

static member Async.AwaitCancellableValueTask: [<InlineIfLambda>] t: CancellableValueTask<'T> -> Async<'T>
static member Async.AwaitCancellableValueTask: [<InlineIfLambda>] t: CancellableValueTask -> Async<unit>
static member Async.AwaitCancellableValueTask: [<InlineIfLambda>] t: CancellableValueTask<'T> -> Async<'T>
static member Async.AwaitCancellableValueTask: [<InlineIfLambda>] t: CancellableValueTask -> Async<unit>

val loadFromAsync: Async<int>

property Async.CancellationToken: Async<CancellationToken> with get

static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>

CancellationToken.ThrowIfCancellationRequested() : unit

val asyncExposedAsCancellableTask: (CancellationToken -> Task<int>)

static member Async.AsCancellableTask: computation: Async<'T> -> (CancellationToken -> Task<'T>)

val asyncExposedAsCancellableValueTask: CancellableValueTask<int>

static member Async.AsCancellableValueTask: computation: Async<'T> -> CancellableValueTask<'T>
static member Async.AsCancellableValueTask: computation: Async<'T> -> CancellableValueTask<'T>

val taskInsideAsyncEx: Async<int>

Task.FromResult<'TResult>(result: 'TResult) : Task<'TResult>

Multiple items
namespace IcedTasks.AsyncEx

--------------------
type AsyncEx = static member AwaitAwaitable: awaitable: 'Awaitable -> Async<'b> (requires member GetAwaiter and 'a :> ICriticalNotifyCompletion and member get_IsCompleted and member GetResult) static member AwaitAwaiter: awaiter: 'Awaiter -> Async<'a> (requires 'Awaiter :> ICriticalNotifyCompletion and member get_IsCompleted and member GetResult) static member AwaitTask: task: Task -> Async<unit> + 1 overload static member AwaitValueTask: vTask: ValueTask<'a> -> Async<'a> + 1 overload
<summary> This contains many functions that implement Task throwing semantics differently than the current FSharp.Core. See <see href="https://github.com/fsharp/fslang-suggestions/issues/840">Async.Await overload (esp. AwaitTask without throwing AggregateException)</see></summary>

static member AsyncEx.AwaitTask: task: Task<'T> -> Async<'T>
static member AsyncEx.AwaitTask: task: Task -> Async<unit>

val valueTaskInsideAsyncEx: Async<int>

static member AsyncEx.AwaitValueTask: vTask: ValueTask -> Async<unit>
static member AsyncEx.AwaitValueTask: vTask: ValueTask<'a> -> Async<'a>

val yieldInsideAsyncEx: Async<unit>

Task.Yield() : YieldAwaitable

static member AsyncEx.AwaitAwaitable: awaitable: 'Awaitable -> Async<'b> (requires member GetAwaiter and 'a :> ICriticalNotifyCompletion and member get_IsCompleted and member GetResult)

Multiple items
type ImmediateAwaiter<'T> = interface ICriticalNotifyCompletion interface INotifyCompletion new: value: 'T -> ImmediateAwaiter<'T> member GetResult: unit -> 'T member OnCompleted: _continuation: Action -> unit member UnsafeOnCompleted: _continuation: Action -> unit member IsCompleted: bool

--------------------
new: value: 'T -> ImmediateAwaiter<'T>

val value: 'T

val _continuation: System.Action

Multiple items
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14,'T15,'T16> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 * arg15: 'T15 * arg16: 'T16 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> unit member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 * arg15: 'T15 * arg16: 'T16 -> unit
<summary>Encapsulates a method that has 16 parameters and does not return a value.</summary>
<param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
<param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
<param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
<param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
<param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param>
<param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param>
<param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param>
<param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param>
<param name="arg9">The ninth parameter of the method that this delegate encapsulates.</param>
<param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param>
<param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param>
<param name="arg12">The twelfth parameter of the method that this delegate encapsulates.</param>
<param name="arg13">The thirteenth parameter of the method that this delegate encapsulates.</param>
<param name="arg14">The fourteenth parameter of the method that this delegate encapsulates.</param>
<param name="arg15">The fifteenth parameter of the method that this delegate encapsulates.</param>
<param name="arg16">The sixteenth parameter of the method that this delegate encapsulates.</param>
<typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T9">The type of the ninth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T12">The type of the twelfth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T13">The type of the thirteenth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T14">The type of the fourteenth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T15">The type of the fifteenth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T16">The type of the sixteenth parameter of the method that this delegate encapsulates.</typeparam>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14,'T15> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 * arg15: 'T15 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> unit member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 * arg15: 'T15 -> unit
<summary>Encapsulates a method that has 15 parameters and does not return a value.</summary>
<param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
<param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
<param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
<param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
<param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param>
<param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param>
<param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param>
<param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param>
<param name="arg9">The ninth parameter of the method that this delegate encapsulates.</param>
<param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param>
<param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param>
<param name="arg12">The twelfth parameter of the method that this delegate encapsulates.</param>
<param name="arg13">The thirteenth parameter of the method that this delegate encapsulates.</param>
<param name="arg14">The fourteenth parameter of the method that this delegate encapsulates.</param>
<param name="arg15">The fifteenth parameter of the method that this delegate encapsulates.</param>
<typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T9">The type of the ninth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T12">The type of the twelfth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T13">The type of the thirteenth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T14">The type of the fourteenth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T15">The type of the fifteenth parameter of the method that this delegate encapsulates.</typeparam>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> unit member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 -> unit
<summary>Encapsulates a method that has 14 parameters and does not return a value.</summary>
<param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
<param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
<param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
<param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
<param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param>
<param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param>
<param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param>
<param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param>
<param name="arg9">The ninth parameter of the method that this delegate encapsulates.</param>
<param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param>
<param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param>
<param name="arg12">The twelfth parameter of the method that this delegate encapsulates.</param>
<param name="arg13">The thirteenth parameter of the method that this delegate encapsulates.</param>
<param name="arg14">The fourteenth parameter of the method that this delegate encapsulates.</param>
<typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T9">The type of the ninth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T12">The type of the twelfth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T13">The type of the thirteenth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T14">The type of the fourteenth parameter of the method that this delegate encapsulates.</typeparam>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> unit member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 -> unit
<summary>Encapsulates a method that has 13 parameters and does not return a value.</summary>
<param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
<param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
<param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
<param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
<param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param>
<param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param>
<param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param>
<param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param>
<param name="arg9">The ninth parameter of the method that this delegate encapsulates.</param>
<param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param>
<param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param>
<param name="arg12">The twelfth parameter of the method that this delegate encapsulates.</param>
<param name="arg13">The thirteenth parameter of the method that this delegate encapsulates.</param>
<typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T9">The type of the ninth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T12">The type of the twelfth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T13">The type of the thirteenth parameter of the method that this delegate encapsulates.</typeparam>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> unit member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 -> unit
<summary>Encapsulates a method that has 12 parameters and does not return a value.</summary>
<param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
<param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
<param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
<param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
<param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param>
<param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param>
<param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param>
<param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param>
<param name="arg9">The ninth parameter of the method that this delegate encapsulates.</param>
<param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param>
<param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param>
<param name="arg12">The twelfth parameter of the method that this delegate encapsulates.</param>
<typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T9">The type of the ninth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T12">The type of the twelfth parameter of the method that this delegate encapsulates.</typeparam>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> unit member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 -> unit
<summary>Encapsulates a method that has 11 parameters and does not return a value.</summary>
<param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
<param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
<param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
<param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
<param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param>
<param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param>
<param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param>
<param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param>
<param name="arg9">The ninth parameter of the method that this delegate encapsulates.</param>
<param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param>
<param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param>
<typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T9">The type of the ninth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> unit member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 -> unit
<summary>Encapsulates a method that has 10 parameters and does not return a value.</summary>
<param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
<param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
<param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
<param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
<param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param>
<param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param>
<param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param>
<param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param>
<param name="arg9">The ninth parameter of the method that this delegate encapsulates.</param>
<param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param>
<typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T9">The type of the ninth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> unit member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 -> unit
<summary>Encapsulates a method that has nine parameters and does not return a value.</summary>
<param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
<param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
<param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
<param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
<param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param>
<param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param>
<param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param>
<param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param>
<param name="arg9">The ninth parameter of the method that this delegate encapsulates.</param>
<typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T9">The type of the ninth parameter of the method that this delegate encapsulates.</typeparam>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> unit member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 -> unit
<summary>Encapsulates a method that has eight parameters and does not return a value.</summary>
<param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
<param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
<param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
<param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
<param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param>
<param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param>
<param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param>
<param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param>
<typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> unit member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 -> unit
<summary>Encapsulates a method that has seven parameters and does not return a value.</summary>
<param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
<param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
<param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
<param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
<param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param>
<param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param>
<param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param>
<typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> unit member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 -> unit
<summary>Encapsulates a method that has six parameters and does not return a value.</summary>
<param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
<param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
<param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
<param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
<param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param>
<param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param>
<typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> unit member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 -> unit
<summary>Encapsulates a method that has five parameters and does not return a value.</summary>
<param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
<param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
<param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
<param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
<param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param>
<typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>

--------------------
type Action<'T1,'T2,'T3,'T4> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> unit member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 -> unit
<summary>Encapsulates a method that has four parameters and does not return a value.</summary>
<param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
<param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
<param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
<param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
<typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>

--------------------
type Action<'T1,'T2,'T3> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> unit member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 -> unit
<summary>Encapsulates a method that has three parameters and does not return a value.</summary>
<param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
<param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
<param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
<typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>

--------------------
type Action<'T1,'T2> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> unit member Invoke: arg1: 'T1 * arg2: 'T2 -> unit
<summary>Encapsulates a method that has two parameters and does not return a value.</summary>
<param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
<param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
<typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
<typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>

--------------------
type Action<'T> = new: object: obj * method: nativeint -> unit member BeginInvoke: obj: 'T * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> unit member Invoke: obj: 'T -> unit
<summary>Encapsulates a method that has a single parameter and does not return a value.</summary>
<param name="obj">The parameter of the method that this delegate encapsulates.</param>
<typeparam name="T">The type of the parameter of the method that this delegate encapsulates.</typeparam>

--------------------
type Action = new: object: obj * method: nativeint -> unit member BeginInvoke: callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> unit member Invoke: unit -> unit
<summary>Encapsulates a method that has no parameters and does not return a value.</summary>

type INotifyCompletion = override OnCompleted: continuation: Action -> unit
<summary>Represents an operation that schedules continuations when it completes.</summary>

val this: ImmediateAwaiter<'T>

val continuation: System.Action

member ImmediateAwaiter.OnCompleted: _continuation: System.Action -> unit

type ICriticalNotifyCompletion = inherit INotifyCompletion override UnsafeOnCompleted: continuation: Action -> unit
<summary>Represents an awaiter that schedules continuations when an await operation completes.</summary>

member ImmediateAwaiter.UnsafeOnCompleted: _continuation: System.Action -> unit

val customAwaiterInsideAsyncEx: Async<int>

static member AsyncEx.AwaitAwaiter: awaiter: 'Awaiter -> Async<'a> (requires 'Awaiter :> ICriticalNotifyCompletion and member get_IsCompleted and member GetResult)

val result1: int

static member Async.RunSynchronously: computation: Async<'T> * ?timeout: int * ?cancellationToken: CancellationToken -> 'T

val result2: int

ValueTask.AsTask() : Task<int>

val result3: int

val result4: int

val result5: int

val result6: int

val result7: int

Multiple items
[<Struct>] type CancellationToken = new: canceled: bool -> unit member Equals: other: obj -> bool + 1 overload member GetHashCode: unit -> int member Register: callback: Action -> CancellationTokenRegistration + 4 overloads member ThrowIfCancellationRequested: unit -> unit member UnsafeRegister: callback: Action<obj,CancellationToken> * state: obj -> CancellationTokenRegistration + 1 overload static member (<>) : left: CancellationToken * right: CancellationToken -> bool static member (=) : left: CancellationToken * right: CancellationToken -> bool member CanBeCanceled: bool member IsCancellationRequested: bool ...
<summary>Propagates notification that operations should be canceled.</summary>

--------------------
CancellationToken ()
CancellationToken(canceled: bool) : CancellationToken

property CancellationToken.None: CancellationToken with get

static member Async.AwaitTask: task: Task -> Async<unit>
static member Async.AwaitTask: task: Task<'T> -> Async<'T>

val result8: int

val result9: int

val result10: int

val result11: unit

val result12: int