Microsoft.AspNetCore.Components.Server

Implements the SignalR Hub Protocol using MessagePack with limited type support.

Options to configure circuit handler for server-side Blazor

Gets or sets a value that determines the maximum number of disconnected circuit state details are retained by the server. When a client disconnects, ASP.NET Core Components attempts to retain state on the server for an interval. This allows the client to re-establish a connection to the existing circuit on the server without losing any state in the event of transient connection issues. This value determines the maximum number of circuit states retained by the server.

Defaults to 100.

Gets or sets a value that determines the maximum duration state for a disconnected circuit is retained on the server. When a client disconnects, ASP.NET Core Components attempts to retain state on the server for an interval. This allows the client to re-establish a connection to the existing circuit on the server without losing any state in the event of transient connection issues. This value determines the maximum duration circuit state is retained by the server before being evicted.

Defaults to 3 minutes.

Gets or sets a value that determines whether or not to send detailed exception messages to JavaScript when an unhandled exception happens on the circuit or when a .NET method invocation through JS interop results in an exception.

This value should only be turned on in development scenarios as turning it on in production might result in the leak of sensitive information to untrusted parties. Defaults to false.

Gets or sets a value that indicates how long the server will wait before timing out an asynchronous JavaScript function invocation.

Defaults to 1 minute.

Gets or sets the maximum number of render batches that a circuit will buffer until an acknowledgement for the batch is received.

When the limit of buffered render batches is reached components will stop rendering and will wait until either the circuit is disconnected and disposed or at least one batch gets acknowledged. Defaults to 10.

Writeable memory stream backed by a an .

Represents a link between a ASP.NET Core Component on the server and a client.

Gets the identifier for the .

A allows running code during specific lifetime events of a . is invoked after an initial circuit to the client has been established. is invoked immediately after the completion of . In addition, the method is invoked each time a connection is re-established with a client after it's been dropped. is invoked each time a connection is dropped. is invoked prior to the server evicting the circuit to the client. Application users may use this event to save state for a client that can be later rehydrated.

Gets the execution order for the current instance of . When multiple instances are registered, the property is used to determine the order in which instances are executed. When two handlers have the same value for , their execution order is non-deterministic.

Defaults to 0.

Invoked when a new circuit was established.

The . A that notifies when the client connection is aborted. that represents the asynchronous execution operation.

Invoked when a connection to the client was established. This method is executed once initially after and once each for each reconnect during the lifetime of a circuit.

The . A that notifies when the client connection is aborted. that represents the asynchronous execution operation.

Invoked when a connection to the client was dropped.

The . The . that represents the asynchronous execution operation.

Invoked when a new circuit is being discarded.

The . The . that represents the asynchronous execution operation.

manages the lifetime of a .

Hosts start off by being registered using . In the simplest of cases, the client disconnects e.g. the user is done with the application and closes the browser. The server (eventually) learns of the disconnect. The host is transitioned from to where it sits with an expiration time. We'll mark the associated as disconnected so that consumers of the Circuit know of the current state. Once the entry for the host in expires, we'll dispose off the host. The alternate case is when the disconnect was transient, e.g. due to a network failure, and the client attempts to reconnect. We'll attempt to connect it back to the host and the preserved server state, when available. In this event, we do the opposite of what we did during disconnect - transition the host from to , and transfer the to use the new client instance that attempted to reconnect to the server. Removing the entry from should ensure we no longer have to concern ourselves with entry expiration. Knowing when a client disconnected is not an exact science. There's a fair possibility that a client may reconnect before the server realizes. Consequently, we have to account for reconnects and disconnects occuring simultaneously as well as appearing out of order. To manage this, we use a critical section to manage all state transitions.

Registers an active with the register.

A Server-Side Blazor implementation of .

Creates a new instance.

The .

Gets or sets whether the circuit has an attached .

Initializes the .

The base URI. The absolute URI.

Initializes the .

The to use for interoperability.

Notifies when a rendering exception occurred.

Creates a new .

Associates the with the , causing it to be displayed in the specified DOM element.

The type of the component. A CSS selector that uniquely identifies a DOM element.

Associates the with the , causing it to be displayed in the specified DOM element.

The type of the component. The parameters for the component. A CSS selector that uniquely identifies a DOM element.

Provides a custom binary serializer for instances. This is designed with both server-side and client-side perf in mind: * Array-like regions always have a fixed size per entry (even if some entry types don't require as much space as others) so the recipient can index directly. * The indices describing where field data starts, where each string value starts, etc., are written *after* that data, so when writing the data we don't have to compute the locations up front or seek back to an earlier point in the stream. The recipient can only process the data after reading it all into a buffer, so it's no disadvantage for the location info to be at the end. * We only serialize the data that the JS side will need. For example, we don't emit frame sequence numbers, or any representation of nonstring attribute values, or component instances, etc. We don't have or need a .NET reader for this format. We only read it from JS code.

Implements a list that uses an array of objects to store the elements. This differs from a in that it not only grows as required but also shrinks if cleared with significant excess capacity. This makes it useful for component rendering, because components can be long-lived and re-render frequently, with the rendered size varying dramatically depending on the user's navigation in the app.

Constructs a new instance of .

Gets the number of items.

Gets the underlying buffer.

Appends a new item, automatically resizing the underlying array if necessary.

The item to append. The index of the appended item.

Sets the supplied value at the specified index. The index must be within range for the array.

The index. The value.

Removes the last item.

Inserts the item at the specified index, moving the contents of the subsequent entries along by one.

The index at which the value is to be inserted. The value to insert.

Marks the array as empty, also shrinking the underlying storage if it was not being used to near its full capacity.

A base class for services that receive an authentication state from the host environment, and revalidate it at regular intervals.

Constructs an instance of .

A logger factory.

Gets the interval between revalidation attempts.

Determines whether the authentication state is still valid.

The current . A to observe while performing the operation. A that resolves as true if the is still valid, or false if it is not.

An intended for use in server-side Blazor.

Gets the default endpoint path for incoming connections.

Provides mechanisms for storing and retrieving data in the browser storage.

Constructs an instance of .

The name of the store in which the data should be stored. The . The .

Asynchronously stores the specified data. Since no data protection purpose is specified with this overload, the purpose is derived from and the store name. This is a good default purpose to use if the keys come from a fixed set known at compile-time.

A value specifying the name of the storage slot to use. A JSON-serializable value to be stored. A representing the completion of the operation.

Asynchronously stores the supplied data.

A string that defines a scope for the data protection. The protected data can only be unprotected by code that specifies the same purpose. A value specifying the name of the storage slot to use. A JSON-serializable value to be stored. A representing the completion of the operation.

Asynchronously retrieves the specified data. Since no data protection purpose is specified with this overload, the purpose is derived from and the store name. This is a good default purpose to use if the keys come from a fixed set known at compile-time.

A value specifying the name of the storage slot to use. A representing the completion of the operation.

Asynchronously retrieves the specified data.

A string that defines a scope for the data protection. The protected data can only be unprotected if the same purpose was previously specified when calling . A value specifying the name of the storage slot to use. A representing the completion of the operation.

Asynchronously deletes any data stored for the specified key.

A value specifying the name of the storage slot whose value should be deleted. A representing the completion of the operation.

Contains the result of a protected browser storage operation.

Gets whether the operation succeeded.

Gets the result value of the operation.

Provides mechanisms for storing and retrieving data in the browser's 'localStorage' collection. This data will be scoped to the current user's browser, shared across all tabs. The data will persist across browser restarts. See: https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage

Constructs an instance of .

The . The .

Provides mechanisms for storing and retrieving data in the browser's 'sessionStorage' collection. This data will be scoped to the current browser tab. The data will be discarded if the user closes the browser tab or closes the browser itself. See: https://developer.mozilla.org/en-US/docs/Web/API/Window/sessionStorage

Constructs an instance of .

The . The .

Implements support for MessagePackHubProtocol. This code is shared between SignalR and Blazor.

Builds conventions that will be used for customization of ComponentHub instances.

Adds the specified convention to the builder. Conventions are used to customize instances.

The convention to add to the builder.

Extensions for .

Maps the Blazor to the default path.

The . The .

Maps the Blazor to the path .

The . The path to map the Blazor . The .

Maps the Blazor to the default path.

The . A callback to configure dispatcher options. The .

Maps the Blazor to the path .

The . The path to map the Blazor . A callback to configure dispatcher options. The .

Holds a byte[] from the pool and a size value. Basically a Memory but guaranteed to be backed by an ArrayPool byte[], so that we know we can return it.

Extension methods to configure an for components.

Adds Server-Side Blazor services to the service collection.

The . A callback to configure . An that can be used to further customize the configuration.

A builder that can be used to configure Server-Side Blazor.

Gets the .

Provides options for configuring Server-Side Blazor.

Adds options to configure circuits.

The . A callback to configure . The .

Adds hub options for the configuration of the SignalR Hub used by Server-Side Blazor.

The . A callback to configure the hub options. The .

Manages a sequence of elements, readily castable as a .

The type of element stored by the sequence. Instance members are not thread-safe.

Initializes a new instance of the class that uses a private for recycling arrays.

Initializes a new instance of the class.

The pool to use for recycling backing arrays.

Initializes a new instance of the class.

The pool to use for recycling backing arrays.

Gets or sets the minimum length for any array allocated as a segment in the sequence. Any non-positive value allows the pool to determine the length of the array.

The default value is 0. Each time or is called, previously allocated memory is used if it is large enough to satisfy the length demand. If new memory must be allocated, the argument to one of these methods typically dictate the length of array to allocate. When the caller uses very small values (just enough for its immediate need) but the high level scenario can predict that a large amount of memory will be ultimately required, it can be advisable to set this property to a value such that just a few larger arrays are allocated instead of many small ones. The in use may itself have a minimum array length as well, in which case the higher of the two minimums dictate the minimum array size that will be allocated.

Gets this sequence expressed as a .

A read only sequence representing the data in this object.

Gets the length of the sequence.

Gets the value to display in a debugger datatip.

Expresses this sequence as a .

The sequence to convert.

Removes all elements from the sequence from its beginning to the specified position, considering that data to have been fully processed.

The position of the first element that has not yet been processed. This is typically after reading all elements from that instance.

Advances the sequence to include the specified number of elements initialized into memory returned by a prior call to .

The number of elements written into memory.

Gets writable memory that can be initialized and added to the sequence via a subsequent call to .

The size of the memory required, or 0 to just get a convenient (non-empty) buffer. The requested memory.

Gets writable memory that can be initialized and added to the sequence via a subsequent call to .

The size of the memory required, or 0 to just get a convenient (non-empty) buffer. The requested memory.

Clears the entire sequence, recycles associated memory into pools, and resets this instance for reuse. This invalidates any previously produced by this instance.

Clears the entire sequence and recycles associated memory into pools. This invalidates any previously produced by this instance.

A value indicating whether the element is a value type.

Gets the backing array, when using an instead of a .

Gets the position within where the data starts.

This may be nonzero as a result of calling .

Gets the position within where the data ends.

Gets the tail of memory that has not yet been committed.

Gets the tracker for the underlying array for this segment, which can be used to recycle the array when we're disposed of. Will be null if using an array pool, in which case the memory is held by .

Gets the full memory owned by the .

Gets the number of elements that are committed in this segment.

Gets the amount of writable bytes in this segment. It is the amount of bytes between and .

Gets or sets the next segment in the singly linked list of segments.

Assigns this (recyclable) segment a new area in memory.

The memory and a means to recycle it.

Assigns this (recyclable) segment a new area in memory.

An array drawn from an .

Clears all fields in preparation to recycle this instance.

Adds a new segment after this one.

The next segment in the linked list.

Commits more elements as written in this segment.

The number of elements written.

Removes some elements from the start of this segment.

The number of elements to ignore from the start of the underlying array.

A fast access struct that wraps .

The underlying .

The result of the last call to , less any bytes already "consumed" with . Backing field for the property.

The result of the last call to , less any bytes already "consumed" with .

The number of uncommitted bytes (all the calls to since the last call to ).

The total number of bytes written with this writer. Backing field for the property.

Initializes a new instance of the struct.

The to be wrapped.

Initializes a new instance of the struct.

The pool from which to draw an if required.. An array to start with so we can avoid accessing the if possible.

Gets the result of the last call to .

Gets the total number of bytes written with this writer.

Gets the underlying this instance.

Calls on the underlying writer with the number of uncommitted bytes.

Used to indicate that part of the buffer has been written to.

The number of bytes written to.

Copies the caller's buffer into this writer and calls with the length of the source buffer.

The buffer to copy in.

Acquires a new buffer if necessary to ensure that some given number of bytes can be written to a single buffer.

The number of bytes that must be allocated in a single buffer.

Gets the span to the bytes written if they were never committed to the underlying buffer writer.

Gets a fresh span to write to, with an optional minimum size.

The minimum size for the next requested buffer.

Copies the caller's buffer into this writer, potentially across multiple buffers from the underlying writer.

The buffer to copy into this writer.

https://github.com/msgpack/msgpack/blob/master/spec.md#serialization-type-to-format-conversion.

The core type codes as defined by msgpack.

Checks whether a given messagepack code represents an integer that might include a sign (i.e. might be a negative number).

The messagepack code. A boolean value.

The officially defined messagepack extension type codes.

A primitive types reader for the MessagePack format.

The MessagePack spec.. Thrown when reading methods fail due to invalid data. Thrown by reading methods when there are not enough bytes to read the required value.

The reader over the sequence.

Initializes a new instance of the struct.

The buffer to read from.

Initializes a new instance of the struct.

The sequence to read from.

Gets or sets the cancellation token for this deserialization operation.

Gets or sets the present depth of the object graph being deserialized.

Gets the originally supplied to the constructor.

Gets the current position of the reader within .

Gets the number of bytes consumed by the reader.

Gets a value indicating whether the reader is at the end of the sequence.

Gets a value indicating whether the reader position is pointing at a nil value.

Thrown if the end of the sequence provided to the constructor is reached before the expected end of the data.

Gets the next message pack type to be read.

Gets the type of the next MessagePack block.

Thrown if the end of the sequence provided to the constructor is reached before the expected end of the data. See for valid message pack codes and ranges.

Initializes a new instance of the struct, with the same settings as this one, but with its own buffer to read from.

The sequence to read from. The new reader.

Creates a new at this reader's current position. The two readers may then be used independently without impacting each other.

A new . Since this is a struct, copying it completely is as simple as returning itself from a property that isn't a "ref return" property.

Advances the reader to the next MessagePack primitive to be read.

The entire primitive is skipped, including content of maps or arrays, or any other type with payloads. To get the raw MessagePack sequence that was skipped, use instead.

Advances the reader to the next MessagePack primitive to be read.

true if the entire structure beginning at the current is found in the ; false otherwise. The entire primitive is skipped, including content of maps or arrays, or any other type with payloads. To get the raw MessagePack sequence that was skipped, use instead.

Reads a value.

A nil value.

Reads nil if it is the next token.

true if the next token was nil; false otherwise. Thrown if the end of the sequence provided to the constructor is reached before the expected end of the data.

Reads a sequence of bytes without any decoding.

The number of bytes to read. The sequence of bytes read.

Reads the next MessagePack primitive.

The raw MessagePack sequence. The entire primitive is read, including content of maps or arrays, or any other type with payloads.

Read an array header from , , or some built-in code between and .

Thrown if the header cannot be read in the bytes left in the or if it is clear that there are insufficient bytes remaining after the header to include all the elements the header claims to be there. Thrown if a code other than an array header is encountered.

Reads an array header from , , or some built-in code between and if there is sufficient buffer to read it.

Receives the number of elements in the array if the entire array header could be read. true if there was sufficient buffer and an array header was found; false if the buffer incompletely describes an array header. Thrown if a code other than an array header is encountered. When this method returns false the position of the reader is left in an undefined position. The caller is expected to recreate the reader (presumably with a longer sequence to read from) before continuing.

Read a map header from , , or some built-in code between and .

The number of key=value pairs in the map. Thrown if the header cannot be read in the bytes left in the or if it is clear that there are insufficient bytes remaining after the header to include all the elements the header claims to be there. Thrown if a code other than an map header is encountered.

Reads a map header from , , or some built-in code between and if there is sufficient buffer to read it.

Receives the number of key=value pairs in the map if the entire map header can be read. true if there was sufficient buffer and a map header was found; false if the buffer incompletely describes an map header. Thrown if a code other than an map header is encountered. When this method returns false the position of the reader is left in an undefined position. The caller is expected to recreate the reader (presumably with a longer sequence to read from) before continuing.

Reads a boolean value from either a or .

The value.

Reads a from any of: , , or anything between and .

A character.

Reads an value from any value encoded with: , , , , , , , , , or some value between and , or some value between and .

The value.

Reads an value from any value encoded with: , , , , , , , , , , or some value between and , or some value between and .

The value.

Reads a from a value encoded with , , or . Expects extension type code .

The value.

Reads a from a value encoded with , , . Expects extension type code .

The extension header that was already read. The value.

Reads a span of bytes, whose length is determined by a header of one of these types: , , , or to support OldSpec compatibility: , , or something beteween and .

A sequence of bytes, or null if the read token is . The data is a slice from the original sequence passed to this reader's constructor.

Reads a string of bytes, whose length is determined by a header of one of these types: , , , or a code between and .

The sequence of bytes, or null if the read token is . The data is a slice from the original sequence passed to this reader's constructor.

Reads a string of bytes, whose length is determined by a header of one of these types: , , , or a code between and .

Receives the span to the string. true if the string is contiguous in memory such that it could be set as a single span. false if the read token is or the string is not in a contiguous span. Callers should generally be prepared for a false result and failover to calling which can represent a null result and handle strings that are not contiguous in memory.

Reads a string, whose length is determined by a header of one of these types: , , , or a code between and .

A string, or null if the current msgpack token is .

Reads an extension format header, based on one of these codes: , , , , , , , or .

The extension header. Thrown if the header cannot be read in the bytes left in the or if it is clear that there are insufficient bytes remaining after the header to include all the bytes the header claims to be there. Thrown if a code other than an extension format header is encountered.

Reads an extension format header, based on one of these codes: , , , , , , , or if there is sufficient buffer to read it.

Receives the extension header if the remaining bytes in the fully describe the header. The number of key=value pairs in the map. Thrown if a code other than an extension format header is encountered. When this method returns false the position of the reader is left in an undefined position. The caller is expected to recreate the reader (presumably with a longer sequence to read from) before continuing.

Reads an extension format header and data, based on one of these codes: , , , , , , , or .

The extension format. The data is a slice from the original sequence passed to this reader's constructor.

Throws an exception indicating that there aren't enough bytes remaining in the buffer to store the promised data.

Throws an explaining an unexpected code was encountered.

The code that was encountered. Nothing. This method always throws.

Throws if a condition is false.

A boolean value. Thrown if is false.

Gets the length of the next string.

The length of the next string.

Reads a string assuming that it is spread across multiple spans in the .

The length of the string to be decoded, in bytes. The decoded string.

Reads an value from: Some value between and , Some value between and , or any of the other MsgPack integer types.