Class ExtendableEvent

Namespace

CSharpToJavaScript.APIs.JS

Assembly

CSharpToJavaScript.dll

The ExtendableEvent interface extends the lifetime of the install and activate events dispatched on the global scope as part of the service worker lifecycle. This ensures that any functional events (like FetchEvent) are not dispatched until it upgrades database schemas and deletes the outdated cache entries.

[Value("ExtendableEvent")]
public class ExtendableEvent : Event

Inheritance

object

Event

ExtendableEvent

Derived

BackgroundFetchEvent

CanMakePaymentEvent

ContentIndexEvent

ExtendableCookieChangeEvent

ExtendableMessageEvent

FetchEvent

InstallEvent

NotificationEvent

PaymentRequestEvent

PeriodicSyncEvent

PushEvent

PushSubscriptionChangeEvent

SyncEvent

Inherited Members

Event.NONE

Event.CAPTURING_PHASE

Event.AT_TARGET

Event.BUBBLING_PHASE

Event.ComposedPath()

Event.StopPropagation()

Event.StopImmediatePropagation()

Event.PreventDefault()

Event.InitEvent(string, bool, bool)

Event.Type

Event.Target

Event.SrcElement

Event.CurrentTarget

Event.EventPhase

Event.CancelBubble

Event.Bubbles

Event.Cancelable

Event.ReturnValue

Event.DefaultPrevented

Event.Composed

Event.IsTrusted

Event.TimeStamp

object.GetType()

object.MemberwiseClone()

object.ToString()

object.Equals(object)

object.Equals(object, object)

object.ReferenceEquals(object, object)

object.GetHashCode()

Remarks

If WaitUntil(Task<dynamic>) is called outside of the ExtendableEvent handler, the browser should throw an InvalidStateError; note also that multiple calls will stack up, and the resulting promises will be added to the list of extend lifetime promises.

This interface inherits from the Event interface.

NOTE

This interface is only available when the global scope is a ServiceWorkerGlobalScope. It is not available when it is a Window, or the scope of another kind of worker.

-Using Service Workers
-Service workers basic code example
-Using web workers

See also on MDN

Constructors

ExtendableEvent()

public ExtendableEvent()

ExtendableEvent(string, ExtendableEventInit)

The ExtendableEvent() constructor creates a new ExtendableEvent object.

public ExtendableEvent(string type, ExtendableEventInit eventInitDict = null)

Parameters

type string

eventInitDict ExtendableEventInit

Remarks

-Using Service Workers
-Service workers basic code example
-Using web workers

See also on MDN

Methods

WaitUntil(Task<dynamic>)

The ExtendableEvent.waitUntil()
method tells the event dispatcher that work is ongoing. It can also be used to detect
whether that work was successful. In service workers, waitUntil() tells
the browser that work is ongoing until the promise settles, and it shouldn&apos;t terminate
the service worker if it wants that work to complete.

[Value("waitUntil")]
public GlobalObject.Undefined WaitUntil(Task<dynamic> f)

Parameters

f Task<dynamic>

Returns

GlobalObject.Undefined

None (GlobalObject.Undefined).

Remarks

The ServiceWorkerGlobalScopeinstall events in service workers use
waitUntil() to hold the service worker in
the Installing phase until tasks
complete. If the promise passed to waitUntil() rejects, the install is
considered a failure, and the installing service worker is discarded. This is primarily
used to ensure that a service worker is not considered installed until all of the core
caches it depends on are successfully populated.

The ServiceWorkerGlobalScopeactivate events in service workers use
waitUntil() to buffer functional events such as fetch and
push until the promise passed to waitUntil() settles. This
gives the service worker time to update database schemas and delete outdated
Cache, so other events can rely on a completely upgraded state.

The waitUntil() method must be initially called within the event callback,
but after that it can be called multiple times, until all the promises passed to it
settle.

-Using Service Workers

See also on MDN