- Generated on Tue Sep 30 2025 07:47:19 for AMPS C# Client by
1.9.1
|
AMPS C# Client
5.3.5.0
AMPS C# Client for .NET
|
| ▼NAMPS | |
| ▼NClient | Interface to provide a recovery point for a bookmark subscription. Used in the RecoveryPointAdapter interface for updates and recovery |
| ►NExceptions | |
| ►NFields | |
| CAuthenticator | Interface used to authenticate an AMPS client user. If authentication was unsuccessful, then an AuthenticationException is thrown. The public repository contains implementations of the authenticator interface. You can use them as examples for your own implementations |
| ►CBlockPublishStore | BlockPublishStore is a base class that implements the Store interface. It is designed for publish store implementations, allowing messages to be stored and managed efficiently. As messages are discarded, space in that buffer is marked "free" for future store operations. If messages are stored faster than they are published, the buffer is re-sized to create more capacity |
| ►CBookmarkRingBuffer | A ring buffer of bookmarks and activation status. Used by all of the bookmark stores to track state of bookmarks we need to hold on to, either because they're active or because they're after an active one |
| CBookmarkStore | Defines the interface for bookmark stores, which are used by the AMPS.Client.Client to provide resumable subscriptions and client-side duplicate message handling |
| CBookmarkStoreResizeHandler | Interface used to indicate whether a BookmarkStore implementation is allowed to grow(or shrink) to the requested size. If the request to resize is denied, a BookmarkStore implementation may choose how to handle the failure: if the bookmark for a message cannot be successfully logged, an implementation may choose to throw an exception or may simply retry the operation until space is available |
| ►CClient | The base AMPS client object used for AMPS applications that do not need a resilient connection to AMPS. Most production applications use the HAClient rather than Client. Each client object manages a single connection to AMPS. Each AMPS connection has a name, a specific transport (such as tcp), a protocol (used for framing messages to AMPS), and a message type(such as FIX or JSON) |
| CClientDisconnectHandler | Called in Client when the Client unintentionally disconnects from AMPS. This interface can be used to implement your own disconnect handler. It will notify you that a Client disconnected so that an action can be taken, such as doing a reconnect |
| CActionDisconnectHandler | Allows the use of an Action (i.e. lambda function with no return value) in any context where a ClientDisconnectHandler may be used |
| CCommand | Command is an encapsulation of a single AMPS command sent by the client. Using Command you can build valid commands to be executed either synchronously or asynchronously via the Client execute() method or asynchronously via the executeAsync() methods |
| CCommandId | Used to give a unique identifier to a Command. This Id can be used to reference the command later, such as when unsubscribing a subscription command |
| CCompletionListener | This interface defines a contract for classes that wish to be notified upon the completion of a specific operation |
| CCompositeMessageBuilder | Used to create payloads for AMPS composite messages, which are messages with a number of parts where each part is a complete message of a specific message type. For example, a composite message type of "composite-json-binary" may be declared on the server that combines a set of JSON headers with an opaque binary payload. CompositeMessageBuilder makes it easy to assemble this payload |
| CCompositeMessageParser | Used to retrieve individual message parts from AMPS composite messages, which are messages where the data contains a number of parts and each part is a complete message of a specific message type. For example, a composite message type of "composite-json-binary" may be declared on the server that combines a set of JSON headers with an opaque binary payload. CompositeMessageParser makes it easy to retrieve the parts of a composite message from the composite message payload |
| CConflatingRecoveryPointAdapter | An implementation of the RecoveryPointAdapter interface that is meant to act as a wrapper around another recovery point adapter instance, delegating periodic updates to its wrapped adapter on an asynchronous update thread (which this instance starts). The intent is to decouple recovery state updates from message discards on a bookmark replay subscriptions so that fast paced subscriptions don't cause a rate of updates that consume too much bandwidth or overwhelm recovery point adapter implementations that use slower storage (slowing message discards) |
| CConnectionInfo | |
| CDefaultAuthenticator | A default implementation of the Authenticator interface that is used for basic username/password authentication |
| CDefaultBookmarkStore | A no-op default implementation of the BookmarkStore interface that does nothing |
| CDefaultCompletionListener | A default implementation of the CompletionListener interface that provides an empty implementation for the completed method |
| CDefaultDisconnectHandler | A default no-op implementation of the ClientDisconnectHandler and TransportDisconnectHandler interfaces that does nothing |
| CDefaultMessageHandler | A default no-op implementation of the MessageHandler interface that does nothing |
| CDefaultServerChooser | A simple ServerChooser that keeps a list of AMPS instances and Authenticators, and advances to the next one when failure occurs |
| CDefaultSubscriptionManager | A no-op implementation of the SubscriptionManager interface that does nothing |
| CDynamicRecoveryPoint | Interface to provide a recovery point for a bookmark subscription. Used in the RecoveryPointAdapter interface for updates and recovery |
| CDynamicRecoveryPointFactory | Class for creating DynamicRecoveryPoint instances |
| ►CExponentialDelayStrategy | ExponentialDelayStrategy is an implementation that exponentially "backs off" when reconnecting to the same server, including optional jitter when backing off and a maximum amount of time to attempt reconnection before giving up entirely |
| CFailedResubscribeHandler | An interface for handling resubscribe failures after a client has failed over to a new server |
| CFailedWriteHandler | An interface for receiving information on messages that you've written, but for which the server indicates are not persisted because of a failure |
| CFailedWriteHandlerV4 | An interface for receiving information on messages that you've written, but for which the server indicates are not persisted because of a failure |
| CFIXBuilder | Used to build up message strings for FIX |
| ►CFixedDelayStrategy | FixedDelayStrategy is an implementation that delays for a fixed time period, as specified in the constructor, when reconnecting to the same server as we were previously connected to, or if we are invoked again for the first server we ever tried. ReconnectDelayStrategy implementations are used by the HAClient |
| CFixedRecoveryPoint | Interface to provide a recovery point for a bookmark subscription. Used in the RecoveryPointAdapter interface for updates and recovery |
| CFixedRecoveryPointFactory | class for creating instances of FixedRecoveryPoint |
| CFIXMessage | A message subclass used by FIXProtocolParser to aid in building Message instances parsed from the FIXProtocol. Generally not used directly by the end user |
| CFIXProtocol | Implements the Protocol interface. Used to parse a byte stream as a series of messages. The byte stream must use the AMPS FIX protocol |
| CFIXProtocolParser | Implements the ProtocolParser interface. Parses a byte stream using FIX protocol |
| CFIXShredder | A parser class which converts a FIX message into a dictionary |
| ►CHAClient | A highly-available AMPS Client object that automatically reconnects and re-subscribes to AMPS instances upon disconnect |
| CHandleTimeoutStream | A Stream implementation that wraps a NetworkStream to keep timeout exceptions from escaping Read and causing the connection to close |
| CHybridPublishStore | A Store implementation that uses memory to hold the newest messages and rolls older messages over to a file |
| CJSONMessage | A message subclass used by JSONProtocolParser to aid in building Message instances parsed from the JSONProtoco (i.e. the "amps" transport protocol). Generally not used directly by the end user |
| CJSONProtocol | Implements the Protocol interface. Used to parse a byte stream as a series of messages. The byte stream must used AMPS FIX protocol |
| CJSONProtocolParser | Implements the ProtocolParser interface. Parses a byte stream using JSON Protocol (AMPS Protocol) |
| CLoggedBookmarkStore | LoggedBookmarkStore implements a sequentially written log of incoming and discarded messages. The store tracks every bookmark processed in a file. An application should periodically call AMPS.Client.LoggedBookmarkStore.prune to manage the size of the file by removing outdated entries. When using LoggedBookmarkStore, it is important to note that this store is intended to provide the ability for the application to fall and resume. If your application does not require this fall-and-resume functionality, it is recommended to use a MemoryBookmarkStore |
| CMemoryBookmarkStore | Implements a bookmark store useful for handling server failover scenarios, but without a backing store to recover from subscriber failure |
| CMemoryPublishStore | An in-memory publish store, used to provide republish capability when in case of failover to an AMPS secondary |
| CMemoryStoreBuffer | MemoryStoreBuffer is a wrapper for a list that maintains position. In order to do this, MemoryStoreBuffer uses a ByteBuffer |
| CMemorySubscriptionManager | An in-memory implementation of SubscriptionManager. Used by HAClient |
| ►CMessage | All communication with AMPS occurs through passing Messages. The AMPS clients provide named convenience methods for core AMPS functionality. These named methods work by creating and sending Messages to AMPS |
| CMessageHandler | |
| CActionMessageHandler | Allows usage of an Action (i.e. a lambda function with no return value) in the place of a MessageHandler throughout the AMPS api |
| CMessageRouter | MessageRouter is used to register and manage a list of handler objects for messages, and then to route messages to those handlers as messages arrive. MessageRouter also "knows" about the meaning of AMPS acks and can use them to automatically clean up routes as acks arrive |
| CMessageStream | MessageStream provides an iteration abstraction over the results of an AMPS command such as a subscribe, a SOW query, or SOW delete. MessageStream is produced when calling Client.execute() and continues iterating over the results until the connection is closed, or the iterator is explicitly closed, or when the SOW query is ended. You can use a MessageStream as you would other Iterators, for example, using a for loop (Java 1.7): |
| CNVFIXBuilder | Used to build up message strings for NVFIX |
| CNVFIXMessage | A message subclass used by NVFIXProtocolParser to aid in building Message instances parsed from the NVFIXProtocol. Generally not used directly by end user |
| CNVFIXProtocol | Implements the Portocol interface. Used to parse a byte stream as a series of messages. The byte stream must use the AMPS NVFIX protocol |
| CNVFIXProtocolParser | Implements the ProtocolParser interface and extends FIXProtocolParser class. Parses a byte stream using NVFIX protocol |
| CNVFIXShredder | A parser class that converts an NVFIX message into a Dictionary |
| CPool | A simple generic instance pool for objects that take a while to construct |
| CProperties | Represents a collection of properties with string keys and string values |
| CProtocol | Interface representing an AMPS wire protocol. Classes that implement this interface aid in parsing a byte stream as a series of messages, formatted using one of the AMPS-supported protocols |
| CProtocolFactory | Class which creates Protocols as well as registering and unregistering them from a Dictionary |
| CProtocolParser | Represents an interface for parsing protocols |
| CPublishStore | PublishStore is a memory-mapped file-backed store for storing outgoing messages. As messages are stored, space is allocated from a pre-created flat buffer on disk. As messages are discarded, space in that buffer is marked "free" for future store operations. If messages are stored faster than they are published, the buffer is re-sized to create more capacity. PublishStore helps in keeping track of unacknowledged messages. If messages are published at a rate exceeding the storage capacity, the buffer is resized to accommodate more messages |
| CPublishStoreResizeHandler | Interface used to indicate whether a Store implementation is allowed to grow (or shrink) to the requested size. If the request to resize is denied, a Store implementation may fail the operation that resulted in the request to grow by throwing an exception |
| CReconnectDelayStrategy | Reconnect delay strategy implementations are called by HAClient to determine how long to wait between attempts to connect or reconnect to a server. AMPS provides two predefined implementations:
|
| CRecoveryPoint | Interface used by RecoveryPointAdapter's to represent a bookmark subscription's recovery state, to allow that subscription to be resumed in a reasonable place when the subscriber application exits and restarts. This is typically a representation for one or more bookmarks, similar to the MOST_RECENT state of a bookmark store that's used for resuming replays. </summart> |
| CRecoveryPointFactory | Interface for creating recovery points |
| CRecoveryPointAdapter | An instance of this interface that can optionally be provided to MemoryBookmarkStore when it's constructed to persist recovery bookmark state for each bookmark replay subscription. The adapter can persist this state to an external store and retrieve it on application restart so that bookmark replay subscriptions can be continued approximately where they left off (with the possible delivery of some duplicate messages). Typically the constructor of any implementation class will take resources needed to connect to / authenticate with the external store and a unique AMPS client name or session name (that stays consistent across application runs) that identifies the AMPS client whose bookmark replay subscriptions want to have their recovery state persisted by this adapter |
| CRingBookmarkStore | |
| CSequencedRecoveryPoint | Represents a recovery point with a sequence number |
| CServerChooser | |
| CSimpleReadBuffer | Represents a simple read buffer used for reading byte data |
| CSOWRecoveryPointAdapter | SOWRecoveryPointAdapter provides functionality for interacting with a SOW (State of the World) topic to facilitate recovery point adaptation |
| CStoreReplayer | |
| CSOWDeleteTypes | SOWDeleteTypes provides constants representing different types of delete operations in a SOW (State of the World) topic |
| CStore | |
| CSubscriptionManager | Interface used to manage all subscriptions in AMPS. This includes: subscribing, unsubscribing and resubscribing |
| CTCPSTransport | Implements a secure transport for communicating with AMPS over a SslStream. System.Net.Security.SslStream |
| CTCPSTransportImpl | The SSL Socket implementation of TCPSTransport. TCPS Transport delegates to an instance of this class. This is used internally by the client's transport. There is usually no reason to make direct use of it. Its functionality is best accessed via the client instance |
| CTCPTransportImpl | Socket implementation for TCPTransport. TCP Transport delegates to an instance of this class. This is used internally by the client's transport. There is usually no reason to make direct use of it. Its functionality is best accessed via the client instance |
| CThreadCreatedHandler | Interface for classes that handle AMPS messages |
| CActionThreadCreatedHandler | Allows usage of an Action (i.e. a lambda function with no return value) in the place of a MessageHandler throughout the AMPS api |
| CTransport | Interface that is used to manage and configure connections to AMPS. Typically a transport is created and used internally by Client instance. There is usually no reason to make direct use of it. Its functionality is best accessed via the client instance |
| CTransportDisconnectHandler | This class is used internally. Customers typically do not need to create their own implementations. This is used by the client's transport to notify the client of disconnection events |
| CTransportFactory | Factory class that allows you to register and unregister handler classes for various connection URI prefixes. Handler class is expected to create a transport when asked. Built-in transports such as "tcp" cannot be unregistered |
| CTransportTraceFilter | An implementation of TransportFilter that traces to a System.IO.TextWriter. To use, instantiate and hen pass to Transport's setTransportFilter, for example: |
| CURIProperties | Provides a Properties interface to the parameters passed in a URI without depending on System.Web |
| ►CUtilities | |
| CVersionInfo | An IComparable representation of the server's version |
| CXMLMessage | A message subclass used by XMLProtocolParser to aid in building Message instances parsed from the XMLProtocol. Generally not used by end user |
| CXMLProtocol | Represents the XML protocol used in the AMPS client |
| CXMLProtocolParser | Implements the ProtocolParser interface. Parses a byte stream using XML protocol |
| CZlibIOStream | A System.IO.Stream wrapper around the ComponentAce zlib implementation which works bidirectionally and eliminates a data copy |
| ▼NComponentAce | |
| ▼NCompression | |
| ►NLibs |
1.9.1