Microsoft.VisualStudio.LiveShare.Rpc

Arguments for an RPC notification or request.

Arguments are represented as one of: - An array of positional arguments - A dictionary of named arguments - An EventArgs object with properties that are named arguments

Matches arguments to a list of method parameters, based on the argument positions, names, and/or types.

Reflected method parameters Arguments array to be filled in by the resolution. Count of arguments to resolve. May be less than the length of parmaeters if final parameter(s) are handled separately. True if the arguments were successfully resolved, or false if the arguments are invalid (in number or type) for the specified parameters.

Matches named arguments to an EventArgs type.

EventArgs subclass Resolved EventArgs instance, or null if the arguments are invalid for the specified EventArgs type.

Matches named arguments to an EventArgs type.

EventArgs subclass Resolved EventArgs instance, or null if the arguments are invalid for the specified EventArgs type.

A chain of RPC message filters. Filters will be called one after another in the order that they were added.

Represents a generic client capable of checking if connection is immediately available.

Check if the connection is readily available.

The cancellation token.

Represents a generic RPC client capable of creating RPC sessions.

The recommended usage pattern is to call once first and then call in order to create an RPC session associated with the connection.

Establishes an RPC connection and initializes internal state.

The cancellation token. It's mandatory to call this method before trying to create an RPC session.

Creates a new RPC session for the current connection.

A cancellation token. The created session. Thrown if the client instance is not connected.

Reconnects this client to a given rpc session.

The rpc session to connect to. Cancellation token. True if reconnect succeeded, false if the host declined the reconnect request.

An RPC filter gets a chance to modify RPC messages immediately before they are sent or after they are received.

Filters a notification message before sending or after receiving.

The notification message being sent or received. True if the notification is about to be sent; false if the notification was just received. The notification message, potentially modified, or null to suppress the notification.

Filters a request message before sending or after receiving.

The request message being sent or received. True if the request is about to be sent; false if the request was just received. The (non-null) request message, potentially modified.

Filters a response message before sending or after receiving.

The request message that generated the response. The response message being sent or received. True if the response is about to be sent; false if the response was just received. The (non-null) response message, potentially modified.

Defines a service that can be registered for use with an RpcSession.

Name of the service. In JSON-RPC requests, notification and request method names are prefixed with the service name (delimited with a period).

Receives a notification from the RPC client.

Notifications cannot be cancelled by the caller. An implementation of this method should avoid a significant synchronous delay.

Receives a request from the RPC client, and returns a response object.

Requests can be cancelled by the caller; request handlers should respond to cancellations via the cancellation token. An implementation of this method should avoid a significant synchronous delay, though any amount of delay is allowed before returning the asynchronous result.

Sends notifications to the RPC client.

Gets a trace source that is used to trace messages related to this service.

Interface for an RPC session - enables a session to be mocked for testing.

Gets or sets stream transport service that allows direct stream connection over the rpc session, or null if there is no such transport.

This property is initially null for a new session, and should be set to IRpcStreamTransport once, before RPC services use this session. Changing this property after that may cause undetermined behavior. It is dependent on the underlying transport like ssh; the RPC library doesn't set or use it. It is merely a convenient way to associate stream transport with a session.

Gets or sets a principal containing claims about the user or server on the other end of the session, or null if the session is not authenticated.

This property is initially null for an unauthenticated session, and should be set to a ClaimsPrincipal instance after successful client or server authentication. The set of claims is application-dependent; the RPC library does not use the claims. The property is merely a convenient way to associate authentication results with a session.

Enables reconnection on this session. If the session doesn't reconnect in 1 min time delay, the session is disposed.

Gets or sets RPC message filter. The filter, if not null, will be applied to: * Requests and notifications before sending them to the RPC stream. * Responses read from from the RPC stream. Filter can be changed when the session is running. Filter used for a request will also be used for the response for that request.

Wait for all previously sent request and notification RPC messages to be written to stream.

Task that completes when all previously sent request and notification RPC messages are written to the stream. If the RPC session disconnectes before all messages are sent

Sends a request and waits asynchronously for a response.

RPC request message Trace source for the request and response message Token for cancelling the request Optional progress object for receiving progress notifications while the request is processing. True if the RPC session should be closed immediately after the response to this request is received (before trying to reading any more bytes from the stream). Async RPC response message The finalRequest parameter allows closing the session without having to cancel a pending read operation, which can be problematic for some kinds of streams (WebSocket / Azure Relay).

Active RPC session

Invokes remote service method.

Notify remote service method

RPC session instrumentation interface. Subscribe to events that RPC session will invoke when it handles RPC.

Event fired when an RPC request is handled.

Gets the raw stream underlying this RPC stream.

RPC implementations that are not wrapping a stream may return null from this property. Therefore any use of this property must check for null.

Reads one message from the RPC stream.

Writes one message to the RPC stream.

Stream transport API to pass stream over RPC session. To use the transport, one can call OpenStreamAsync, while the other side of the RPC sessions should handle StreamOpening event.

A value indicating whether random access streams can be passed

Event that fires when the other side of RPC session tries to opens a stream.

Opens a direct stream over the RPC session

Stream id. A cancellation token.

Event args for the event that stream transport fires when a stream opens

Stream id

Stream over the RPC session

A value indicating whether the handler authorizes opening of the stream. If set to true by the handler, OpenStreamAsync will succeed, and the handler must assume the ownership of Stream and use it to communicate with the other party.

Base class for a top-level JSON-RPC message.

A JSON-RPC message to mimic keep-alive TCP packet.

A JSON-RPC message to enable reconnection due to network disruptions.

A JSON-RPC message that has no ID and no response.

A JSON-RPC message that has an ID and requires a response.

Gets or sets the progress value.

If the progress value is a non-primitive type, the return value may not be resolved properly. Use the generic method instead.

Gets the progress value, resolved to a specific type.

Response message for a JSON-RPC request.

Array of times in milliseconds taken to send/receive/respond to requests

Includes times from sending requests to receiving responses and time from receiving requests to returning responses. E.g. a simple scenario where A makes a request to B: A sends a request to B and begins timing. B receives the request and begins timing. B processes the request. B is ready to resolve the request, so stops timing, stamps the time it took to respond on the response message, and sends the reponse. A receives the response, stops timing, subtracts off the time taken for B to respond (this time is included in the response message) and adds another item to the list of handling times on the response message. The first time in the list of handling times is the amount of time it took B to process the request, and the second time in the list is the communication latency between A and B. In more complicated scenarios where requests go through multiple clients, the list of handling times can be used to find the communication latency between each RPC client in the chain, and how long processing took at each client. In general, the last client in the chain will only contribute one time to the list: the amount of time it took to respond to the request. So this is always the first item in the list. Similarly, the first client in the chain (the one that made the initial request) only contributes one time to the list: the communication latency between itself and the first client in the chain. So this is always the last item in the list. Intermediate clients contribute 2 times each: the first is the communication latency between the client and the next in the chain. The second is the time it took the client to do any intermediate processing before forwarding the request on to the next client and returning the response to the previous client. E.g. if HandlingTimes = [a, b, c, d], there were three clients involved in the request. a is the time it took the last client to handle the request, b is the communication latency between the second and third client, c is the time it took the second client from receiving the request from the first client to forward the request to the third client plus the time from receiving the response from the third client to sending it to the first client, and d is the communication latency between the first and second client. The full time from the first client making the request to receiving the response is a + b + c + d. In general, the latency of the request is the sum of every other item in the list, starting at index 1 (here b + d), and the processing time is the sum of every other item in the list, starting at index 0 (here a + c).

Error details for a JSON-RPC error response.

Event arguments for exception thrown event

Named pipe server that can accept multiple connections.

Starts and runs the named pipe server until is cancelled. Disposes the server after that and throws OperationCancelledException

Cancellation token that controls the life time of the server Server task

No flags.

The child processes of a process associated with a job are not associated with the job. If the calling process is not associated with a job, this constant has no effect. If the calling process is associated with a job, the job must set the JOB_OBJECT_LIMIT_BREAKAWAY_OK limit.

The new process does not inherit the error mode of the calling process. Instead, the new process gets the default error mode. This feature is particularly useful for multithreaded shell applications that run with hard errors disabled. The default behavior is for the new process to inherit the error mode of the caller. Setting this flag changes that default behavior.

The new process has a new console, instead of inheriting its parent's console (the default). For more information, see Creation of a Console. This flag cannot be used with DETACHED_PROCESS.

The new process is the root process of a new process group. The process group includes all processes that are descendants of this root process. The process identifier of the new process group is the same as the process identifier, which is returned in the lpProcessInformation parameter. Process groups are used by the GenerateConsoleCtrlEvent function to enable sending a CTRL+BREAK signal to a group of console processes. If this flag is specified, CTRL+C signals will be disabled for all processes within the new process group. This flag is ignored if specified with .

The process is a console application that is being run without a console window. Therefore, the console handle for the application is not set. This flag is ignored if the application is not a console application, or if it is used with either or .

The process is to be run as a protected process. The system restricts access to protected processes and the threads of protected processes. For more information on how processes can interact with protected processes, see Process Security and Access Rights. To activate a protected process, the binary must have a special signature. This signature is provided by Microsoft but not currently available for non-Microsoft binaries. There are currently four protected processes: media foundation, audio engine, Windows error reporting, and system. Components that load into these binaries must also be signed. Multimedia companies can leverage the first two protected processes. For more information, see Overview of the Protected Media Path. Windows Server 2003 and Windows XP: This value is not supported.

Allows the caller to execute a child process that bypasses the process restrictions that would normally be applied automatically to the process.

This flag is valid only when starting a 16-bit Windows-based application. If set, the new process runs in a private Virtual DOS Machine (VDM). By default, all 16-bit Windows-based applications run as threads in a single, shared VDM. The advantage of running separately is that a crash only terminates the single VDM; any other programs running in distinct VDMs continue to function normally. Also, 16-bit Windows-based applications that are run in separate VDMs have separate input queues. That means that if one application stops responding momentarily, applications in separate VDMs continue to receive input. The disadvantage of running separately is that it takes significantly more memory to do so. You should use this flag only if the user requests that 16-bit applications should run in their own VDM.

The flag is valid only when starting a 16-bit Windows-based application. If the DefaultSeparateVDM switch in the Windows section of WIN.INI is TRUE, this flag overrides the switch. The new process is run in the shared Virtual DOS Machine.

The primary thread of the new process is created in a suspended state, and does not run until the function is called.

If this flag is set, the environment block pointed to by lpEnvironment uses Unicode characters. Otherwise, the environment block uses ANSI characters.

The calling thread starts and debugs the new process. It can receive all related debug events using the WaitForDebugEvent function.

The calling thread starts and debugs the new process and all child processes created by the new process. It can receive all related debug events using the WaitForDebugEvent function. A process that uses becomes the root of a debugging chain. This continues until another process in the chain is created with . If this flag is combined with , the caller debugs only the new process, not any child processes.

For console processes, the new process does not inherit its parent's console (the default). The new process can call the function at a later time to create a console. For more information, see Creation of a Console. This value cannot be used with .

The process is created with extended startup information; the lpStartupInfo parameter specifies a structure. Windows Server 2003 and Windows XP: This value is not supported.

The process inherits its parent's affinity. If the parent process has threads in more than one processor group, the new process inherits the group-relative affinity of an arbitrary group in use by the parent. Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: This value is not supported.

A handle to the newly created process. The handle is used to specify the process in all functions that perform operations on the process object.

A handle to the primary thread of the newly created process. The handle is used to specify the thread in all functions that perform operations on the thread object.

A value that can be used to identify a process. The value is valid from the time the process is created until all handles to the process are closed and the process object is freed; at this point, the identifier may be reused.

A value that can be used to identify a thread. The value is valid from the time the thread is created until all handles to the thread are closed and the thread object is freed; at this point, the identifier may be reused.

Represents a Win32 handle that can be closed with .

An invalid handle that may be used in place of .

A handle that may be used in place of .

Initializes a new instance of the class.

An object that represents the pre-existing handle to use. to have the native handle released when this safe handle is disposed or finalized; otherwise.

Specifies the window station, desktop, standard handles, and appearance of the main window for a process at creation time.

The size of this data structure.

Reserved; must be NULL. Actual type: char*.

The name of the desktop, or the name of both the desktop and window station for this process. A backslash in the string indicates that the string includes both the desktop and window station names. For more information, see Thread Connection to a Desktop. Actual type: char*.

For console processes, this is the title displayed in the title bar if a new console window is created. If NULL, the name of the executable file is used as the window title instead. This parameter must be NULL for GUI or console processes that do not create a new console window. Actual type: char*.

If specifies STARTF_USEPOSITION, this member is the x offset of the upper left corner of a window if a new window is created, in pixels. Otherwise, this member is ignored. The offset is from the upper left corner of the screen. For GUI processes, the specified position is used the first time the new process calls CreateWindow to create an overlapped window if the x parameter of CreateWindow is CW_USEDEFAULT.

If specifies STARTF_USEPOSITION, this member is the y offset of the upper left corner of a window if a new window is created, in pixels. Otherwise, this member is ignored. The offset is from the upper left corner of the screen. For GUI processes, the specified position is used the first time the new process calls CreateWindow to create an overlapped window if the y parameter of CreateWindow is CW_USEDEFAULT.

If specifies STARTF_USESIZE, this member is the width of the window if a new window is created, in pixels. Otherwise, this member is ignored. For GUI processes, this is used only the first time the new process calls CreateWindow to create an overlapped window if the nWidth parameter of CreateWindow is CW_USEDEFAULT.

If specifies STARTF_USESIZE, this member is the height of the window if a new window is created, in pixels. Otherwise, this member is ignored. For GUI processes, this is used only the first time the new process calls CreateWindow to create an overlapped window if the nHeight parameter of CreateWindow is CW_USEDEFAULT.

If specifies STARTF_USECOUNTCHARS, if a new console window is created in a console process, this member specifies the screen buffer width, in character columns. Otherwise, this member is ignored.

If specifies STARTF_USECOUNTCHARS, if a new console window is created in a console process, this member specifies the screen buffer height, in character rows. Otherwise, this member is ignored.

If specifies STARTF_USEFILLATTRIBUTE, this member is the initial text and background colors if a new console window is created in a console application. Otherwise, this member is ignored. This value can be any combination of the following values: FOREGROUND_BLUE, FOREGROUND_GREEN, FOREGROUND_RED, FOREGROUND_INTENSITY, BACKGROUND_BLUE, BACKGROUND_GREEN, BACKGROUND_RED, and BACKGROUND_INTENSITY. For example, the following combination of values produces red text on a white background: FOREGROUND_RED| BACKGROUND_RED| BACKGROUND_GREEN| BACKGROUND_BLUE.

A bitfield that determines whether certain STARTUPINFO members are used when the process creates a window.

If specifies , this member can be any of the values that can be specified in the nCmdShow parameter for the ShowWindow function, except for SW_SHOWDEFAULT. Otherwise, this member is ignored. For GUI processes, the first time ShowWindow is called, its nCmdShow parameter is ignored wShowWindow specifies the default value. In subsequent calls to ShowWindow, the wShowWindow member is used if the nCmdShow parameter of ShowWindow is set to SW_SHOWDEFAULT.

Reserved for use by the C Run-time; must be zero.

Reserved for use by the C Run-time; must be NULL.

If specifies , this member is the standard input handle for the process. If is not specified, the default for standard input is the keyboard buffer. If specifies , this member specifies a hotkey value that is sent as the wParam parameter of a WM_SETHOTKEY message to the first eligible top-level window created by the application that owns the process. If the window is created with the WS_POPUP window style, it is not eligible unless the WS_EX_APPWINDOW extended window style is also set. For more information, see CreateWindowEx. Otherwise, this member is ignored.

If specifies , this member is the standard output handle for the process. Otherwise, this member is ignored and the default for standard output is the console window's buffer. If a process is launched from the taskbar or jump list, the system sets to a handle to the monitor that contains the taskbar or jump list used to launch the process. For more information, see Remarks. Windows 7, Windows Server 2008 R2, Windows Vista, Windows Server 2008, Windows XP, and Windows Server 2003: This behavior was introduced in Windows 8 and Windows Server 2012.

If specifies , this member is the standard error handle for the process. Otherwise, this member is ignored and the default for standard error is the console window's buffer.

Gets the value of as a string.

Initializes a new instance of the struct.

An initialized instance of the struct.

A bitfield that determines whether certain members are used when the process creates a window.

No flags.

Indicates that the cursor is in feedback mode for two seconds after is called. The Working in Background cursor is displayed (see the Pointers tab in the Mouse control panel utility). If during those two seconds the process makes the first GUI call, the system gives five more seconds to the process. If during those five seconds the process shows a window, the system gives five more seconds to the process to finish drawing the window. The system turns the feedback cursor off after the first call to GetMessage, regardless of whether the process is drawing.

Indicates that the feedback cursor is forced off while the process is starting. The Normal Select cursor is displayed.

Indicates that any windows created by the process cannot be pinned on the taskbar. This flag must be combined with .

Indicates that the process should be run in full-screen mode, rather than in windowed mode. This flag is only valid for console applications running on an x86 computer.

The lpTitle member contains an AppUserModelID. This identifier controls how the taskbar and Start menu present the application, and enables it to be associated with the correct shortcuts and Jump Lists. Generally, applications will use the SetCurrentProcessExplicitAppUserModelID and GetCurrentProcessExplicitAppUserModelID functions instead of setting this flag. For more information, see Application User Model IDs. If is used, application windows cannot be pinned on the taskbar. The use of any AppUserModelID-related window properties by the application overrides this setting for that window only. This flag cannot be used with .

The lpTitle member contains the path of the shortcut file (.lnk) that the user invoked to start this process. This is typically set by the shell when a .lnk file pointing to the launched application is invoked. Most applications will not need to set this value. This flag cannot be used with .

The command line came from an untrusted source. For more information, see Remarks.

The and members contain additional information.

The member contains additional information.

The member contains additional information. This flag cannot be used with .

The and members contain additional information.

The member contains additional information.

The and members contain additional information.

The , , and members contain additional information. If this flag is specified when calling one of the process creation functions, the handles must be inheritable and the function's bInheritHandles parameter must be set to TRUE. For more information, see Handle Inheritance. If this flag is specified when calling the function, these members are either the handle value specified during process creation or . Handles must be closed with when they are no longer needed. This flag cannot be used with .

Standard handles for the method.

The standard input device. Initially, this is the console input buffer, CONIN$.

The standard output device. Initially, this is the active console screen buffer, CONOUT$.

The standard error device. Initially, this is the active console screen buffer, CONOUT$.

Fires if session is in disconnected state, and then disposes the session.

Client for opening a JSON-RPC session over a named pipe.

Check if the connection is readily available.

The cancellation token.

Server for accepting JSON-RPC sessions over a named pipe.

Basic implementation of the interface.

Type of progress value .NET's class runs the actions on a background thread, which means they may get handled out of order or after the operation finishes. That may be good for some scenarios, but it's probably unexpected with working with RPC. So this class may be used instead.

Relays details about an unhandled exception thrown by the remote handler of an RPC request.

Arguments for an event raised when an RPC session disconnects, either due to a direct call to or because the underlying stream disconnected.

Message describing the reason for disconnection.

Optional exception that was the cause of the disconnection.

An event-handler may set this property to `true` to prevent disposal of the sesssion and enable it to be reconnected at a later time.

Exception thrown by RPC send request when it cannot do that because either there was a stream error writing the request message, or the stream has been closed before the response has arrived. This can be thrown in two cases: 1. When RPC cannot write a request message and closes the session because of that. In this case InnerException will have the exception occured during writing. 2. When the session is disconnected, either explicitly, or due to some error.

Uses reflection to dispatch incoming notifications and requests to the appropriate service method, and send outgoing notifications in response to events raised by the service.

Interface that defines the RPC service methods and notification events.

Creates a new dispatcher for a service.

Registered name of the service. Implementation of the service interface. In addition to implementing the service interface methods raising interface events, services that wish to RECEIVE events (notifications) via the dispatcher must implement methods of the form: void OnEventName(object sender, EventArgsType e) where `EventName` is the name of the RPC notification, as declared by the contract, and `EventArgsType` is the type of event args declared by the contract.

Error codes defined by the JSON-RPC spec or this JSON-RPC implementation.

Relay for RPC service notifications. Enables an RpcRelay to raise notification events originated by a remote service.

Dynamically generates a proxy for an RPC interface, using the service name from the interface's service contract attribute.

RPC interface type RPC session used by the proxy Source for tracing activity and errors from the proxy Optional filter for request and response messages. Implementation of the interface that proxies requests/notifications to/from the remote service.

Dynamically generates a proxy for an RPC interface, using the service name from the interface's service contract attribute.

Dynamically generates a proxy for an RPC interface, using a provided service name.

RPC interface type Name of the RPC service to proxy RPC session used by the proxy Source for tracing activity and errors from the proxy Optional filter for request and response messages. Implementation of the interface that proxies requests/notifications to/from the remote service.

Dynamically generates a proxy for an RPC interface, using a provided service name.

Searches an interface and its base interfaces (if any) for members of a given type.

Recursive helper for getting interface methods.

Emits a class that extends RpcProxy and implements all of an interface's methods and events.

Emits a constructor that forwards arguments to the base RpcProxy constructor.

Emits a method that forwards arguments to the Invoke, InvokeAsync, or InvokeWithResultAsync method on the base RpcProxy.

Emits an event with standard add/remove implementation.

Relay for a remote RPC service. Relays incoming requests to the remote service, and relays responses back to the client. Can work with an RpcEventRelay to also relay notifications from the remote service.

Holds a collection of RPC service provider instances for the same service name. Any of the service providers may emit notifications, however requests made to the collection will return errors due to the ambiguity.

Holds a mapping from service names to services (potentially multiple services with the same name), along with optional service owner information that enables removing services by name or removing all services associated with a certain owner.

Gets an to all services of the given name.

The service name.

Performs a deep copy of the contents of this service map into another map. Throws an exception if there are any duplicate service name or owner keys.

Helper class for the IRpcService interface

Class to report and Rpc message being sent or received

If an event handler already handled this rpc message and prevent the Session to pass it to the Stream

Message being sent or received

Manages an RPC connection from a single client. Dispatches requests to the RPC services, and returns responses back to the client.

Gets async local RPC session. Rpc servers can check this field to know what RPC session is calling them.

Gets message conext of the active RPC request or an empty dictionary.

Event raised when the session disconnects, either due to a direct call to or because the underlying stream disconnected.

Exceptions thrown by event handlers are traced to the trace source. They do not prevent to call other multicast delegates and then terminate the RPC message processing.

Event fired when an RPC request is handled.

Disconnects the session and disposes the underlying stream.

Message describing the reason for disconnection. Optional exception that was the cause of the disconnection.

Disposes the RPC session and disconnects from the stream. Any processing of inbound requests is cancelled, and any pending outbound requests fail with an .

Connects or RE-connects the RPC session to a stream.

Re-connection enables an RPC session to be resumed without losing all the state (RPC services and pending requests) on one side or both sides. To enable re-connection, handle the event and set the flag to true on one side or both sides of the session. That prevents the RPC session from being disposed by the disconnect, and retains the registration of services. Additionally, any RPC requests that were pending / incomplete at the time of the disconnect will automatically be re-sent upon reconnection.

Who hosts RPC server, handles RPC requests, and who may be the RPC client.

RPC between the client and the agent, the agent is the server. RPC starts when the client loads Live Share on startup and it then starts the agent.

RPC between the host and a guest, the host client is the server. The host agent just forwards RPC through to the client. RPC starts when a guest connects.

RPC between the host and a guest, the host agent is the server. RPC starts when a guest connects.

Rpc Stream options

Event raised by an RpcServiceMap when services are added to or removed from the map.

Gets the owner for the services changed if specified.

If a service is mapped to an owner but a did not specify that owner when requested, this will be null.

Client for opening a JSON-RPC session over a TCP socket connection.

Server for accepting JSON-RPC sessions over a TCP socket connection.

Finds and returns an available port within the specified range (inclusive).

Available port, or 0 if no available port was found.

Creates a TCP listener that listens on all local addresses for both IPv6 and IPv4.

Core interface of the cascade client

Filters for RPC request and response messages.

Exception thrown when operation cannot be performed because client (guest) has insufficient access. E.g. mutating operation in read-only session.

Original .Net Framework constructors from decompiled code

Create a new . All default parameters are copied from the original constructors.

Assembly version information for Microsoft.VisualStudio.LiveShare.Rpc.dll assembly

Assembly version.

Assembly name (without .dll extension)

File name (with .dll extension)

Public key token.