BackgroundService and BackgroundTask Example

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 

open Services
open System.Threading
open Microsoft.Extensions.Hosting
open System.Threading.Tasks

[<AbstractClass>]
type BackgroundService () = 
    let mutable BackgroundTask : Task = null
    let CancelTokenSource : CancellationTokenSource = new CancellationTokenSource()
    abstract Execute : CancellationToken -> unit
    interface IHostedService with
        override x.StartAsync (cancellationToken : CancellationToken) : Task =
            let ct = CancelTokenSource.Token
            BackgroundTask <- Task.Factory.StartNew(fun () -> x.Execute(ct), ct, TaskCreationOptions.LongRunning, TaskScheduler.Default)
            Task.CompletedTask
        override x.StopAsync (cancellationToken : CancellationToken) : Task =
            CancelTokenSource.Cancel()
            Task.CompletedTask

type PeriodicService () =
    inherit BackgroundService()
    let delay = 15 * 1000
    override x.Execute ct =
        while not ct.IsCancellationRequested do
            try
                printfn "Periodic Executing..."
                // do your thing
                Task.Delay delay |> Async.AwaitTask |> Async.RunSynchronously
            with
            | e -> printfn "Caught %s %s" e.Message e.StackTrace
        printfn "[CANCEL] Periodic service"

namespace System

namespace System.Threading

namespace Microsoft

namespace System.Threading.Tasks

Multiple items
type AbstractClassAttribute =
  inherit Attribute
  new : unit -> AbstractClassAttribute

--------------------
new : unit -> AbstractClassAttribute

Multiple items
type BackgroundService =
  interface obj
  new : unit -> BackgroundService
  abstract member Execute : CancellationToken -> unit
  override StartAsync : cancellationToken:CancellationToken -> Task
  override StopAsync : cancellationToken:CancellationToken -> Task

--------------------
new : unit -> BackgroundService

val mutable BackgroundTask : Task

Multiple items
type Task =
  new : action:Action -> Task + 7 overloads
  member AsyncState : obj
  member ConfigureAwait : continueOnCapturedContext:bool -> ConfiguredTaskAwaitable
  member ContinueWith : continuationAction:Action<Task> -> Task + 19 overloads
  member CreationOptions : TaskCreationOptions
  member Dispose : unit -> unit
  member Exception : AggregateException
  member GetAwaiter : unit -> TaskAwaiter
  member Id : int
  member IsCanceled : bool
  ...

--------------------
type Task<'TResult> =
  inherit Task
  new : function:Func<'TResult> -> Task<'TResult> + 7 overloads
  member ConfigureAwait : continueOnCapturedContext:bool -> ConfiguredTaskAwaitable<'TResult>
  member ContinueWith : continuationAction:Action<Task<'TResult>> -> Task + 19 overloads
  member GetAwaiter : unit -> TaskAwaiter<'TResult>
  member Result : 'TResult
  static member Factory : TaskFactory<'TResult>

--------------------
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<'TResult>, cancellationToken: CancellationToken) : Task<'TResult>
Task(function: System.Func<'TResult>, creationOptions: TaskCreationOptions) : Task<'TResult>
Task(function: System.Func<obj,'TResult>, state: obj) : Task<'TResult>
Task(function: System.Func<'TResult>, cancellationToken: CancellationToken, 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<obj,'TResult>, state: obj, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions) : Task<'TResult>

val CancelTokenSource : CancellationTokenSource

Multiple items
type CancellationTokenSource =
  new : unit -> CancellationTokenSource + 2 overloads
  member Cancel : unit -> unit + 1 overload
  member CancelAfter : delay:TimeSpan -> unit + 1 overload
  member Dispose : unit -> unit
  member IsCancellationRequested : bool
  member Token : CancellationToken
  static member CreateLinkedTokenSource : [<ParamArray>] tokens:CancellationToken[] -> CancellationTokenSource + 1 overload

--------------------
CancellationTokenSource() : CancellationTokenSource
CancellationTokenSource(delay: System.TimeSpan) : CancellationTokenSource
CancellationTokenSource(millisecondsDelay: int) : CancellationTokenSource

Multiple items
type CancellationToken =
  struct
    new : canceled:bool -> CancellationToken
    member CanBeCanceled : bool
    member Equals : other:CancellationToken -> bool + 1 overload
    member GetHashCode : unit -> int
    member IsCancellationRequested : bool
    member Register : callback:Action -> CancellationTokenRegistration + 3 overloads
    member ThrowIfCancellationRequested : unit -> unit
    member UnsafeRegister : callback:Action<obj> * state:obj -> CancellationTokenRegistration
    member WaitHandle : WaitHandle
    static member None : CancellationToken
  end

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

type unit = Unit

val x : BackgroundService

val cancellationToken : CancellationToken

val ct : CancellationToken

property CancellationTokenSource.Token: CancellationToken with get

Multiple items
property Task.Factory: TaskFactory<'TResult> with get

--------------------
property Task.Factory: TaskFactory with get

Multiple items
TaskFactory.StartNew(function: System.Func<'TResult>) : Task<'TResult>
TaskFactory.StartNew(function: System.Func<obj,'TResult>, state: obj) : Task<'TResult>
TaskFactory.StartNew(function: System.Func<'TResult>, creationOptions: TaskCreationOptions) : Task<'TResult>
TaskFactory.StartNew(function: System.Func<'TResult>, cancellationToken: CancellationToken) : Task<'TResult>
TaskFactory.StartNew(function: System.Func<obj,'TResult>, state: obj, creationOptions: TaskCreationOptions) : Task<'TResult>
TaskFactory.StartNew(function: System.Func<obj,'TResult>, state: obj, cancellationToken: CancellationToken) : Task<'TResult>
TaskFactory.StartNew(function: System.Func<'TResult>, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions, scheduler: TaskScheduler) : Task<'TResult>
TaskFactory.StartNew(function: System.Func<obj,'TResult>, state: obj, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions, scheduler: TaskScheduler) : Task<'TResult>

--------------------
TaskFactory.StartNew<'TResult>(function: System.Func<'TResult>) : Task<'TResult>
   (+0 other overloads)
TaskFactory.StartNew(action: System.Action) : Task
   (+0 other overloads)
TaskFactory.StartNew<'TResult>(function: System.Func<obj,'TResult>, state: obj) : Task<'TResult>
   (+0 other overloads)
TaskFactory.StartNew<'TResult>(function: System.Func<'TResult>, creationOptions: TaskCreationOptions) : Task<'TResult>
   (+0 other overloads)
TaskFactory.StartNew<'TResult>(function: System.Func<'TResult>, cancellationToken: CancellationToken) : Task<'TResult>
   (+0 other overloads)
TaskFactory.StartNew(action: System.Action<obj>, state: obj) : Task
   (+0 other overloads)
TaskFactory.StartNew(action: System.Action, creationOptions: TaskCreationOptions) : Task
   (+0 other overloads)
TaskFactory.StartNew(action: System.Action, cancellationToken: CancellationToken) : Task
   (+0 other overloads)
TaskFactory.StartNew<'TResult>(function: System.Func<obj,'TResult>, state: obj, creationOptions: TaskCreationOptions) : Task<'TResult>
   (+0 other overloads)
TaskFactory.StartNew<'TResult>(function: System.Func<obj,'TResult>, state: obj, cancellationToken: CancellationToken) : Task<'TResult>
   (+0 other overloads)

abstract member BackgroundService.Execute : CancellationToken -> unit

type TaskCreationOptions =
  | None = 0
  | PreferFairness = 1
  | LongRunning = 2
  | AttachedToParent = 4
  | DenyChildAttach = 8
  | HideScheduler = 16
  | RunContinuationsAsynchronously = 64

field TaskCreationOptions.LongRunning: TaskCreationOptions = 2

type TaskScheduler =
  member Id : int
  member MaximumConcurrencyLevel : int
  static member Current : TaskScheduler
  static member Default : TaskScheduler
  static member FromCurrentSynchronizationContext : unit -> TaskScheduler
  static event UnobservedTaskException : EventHandler<UnobservedTaskExceptionEventArgs>

property TaskScheduler.Default: TaskScheduler with get

property Task.CompletedTask: Task with get

CancellationTokenSource.Cancel() : unit
CancellationTokenSource.Cancel(throwOnFirstException: bool) : unit

Multiple items
type PeriodicService =
  inherit BackgroundService
  new : unit -> PeriodicService
  override Execute : ct:CancellationToken -> unit

--------------------
new : unit -> PeriodicService

val delay : int

val x : PeriodicService

val not : value:bool -> bool

property CancellationToken.IsCancellationRequested: bool with get

val printfn : format:Printf.TextWriterFormat<'T> -> 'T

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

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 -> Async<unit>
  static member AwaitTask : task:Task<'T> -> Async<'T>
  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:seq<Async<'T option>> -> Async<'T option>
  static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
  ...

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

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

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

val e : exn

property System.Exception.Message: string with get

property System.Exception.StackTrace: string with get