ThermoFisher.Foundation.Utilities

Observer interface, where observee communicates an event to another observer,

Notifies the specified event data.

The data part is useful to let the observer know of data needs and the observer is passed for type checking. To ensure that your notify was called with the correct object, test if (this == observer). Also, haveing the observer parameter insures that if a class/object derives from more than one event interface, there will be a separate Notify method for each event. The event data. The observer interface.

Observee interface, where observers get notified during an event.

Adds the specified derived observer.

The derived observer.

Removes the specified derived observer.

This is unnecessary since the gc will unload the observers from the list. But is here for completeness. The derived observer.

Notifies all the observees of the event.

The event data.

Gets the count of observers we have.

The count.

Connect to the first ip address of the host the match the address family

Host name to resolve Port to connect

Class Blob serves to hold a byte-array buffer and methods for creating and accessing it. Use NetMQFrame instead; Blob is still present simply for backward compatibility.

Create a new Blob object containing the given data, and with a data-buffer of the given size.

the byte-array of data for this Blob to contain the length in bytes to allocate to the data buffer

Create a new Blob object with a data-buffer of the given size.

the length in bytes to allocate to the data buffer

Put the given byte into the data buffer at the indicated position.

the (zero-based) index of the data buffer to put the byte into the byte to write into the buffer a reference to this Blob so that other method-calls may be chained

Put the given byte into the data buffer at the indicated position.

the (zero-based) index of the data buffer to put the byte into the byte-array data to write into the data buffer how many bytes of data to write into the data buffer a reference to this Blob so that other method-calls may be chained

Return true if this Blob is equal to the given object.

the other object to compare against true if equal

Return an integer hash-code to use to uniquely identify this Blob object.

the hash-code

Get the length of the data-buffer (the number of bytes in the array).

Get the data buffer contained by this Blob, as a byte-array.

The IBufferPool interface specifies two methods: Take, and Return. These provide for taking byte-array data from a common pool, and returning it.

Take byte-array storage from the buffer-pool.

the number of bytes to take a byte-array that comes from the buffer-pool

Return the given byte-array buffer to the common buffer-pool.

the byte-array to return to the buffer-pool

This implementation of uses WCF's class to manage a pool of buffers.

Create a new BufferManagerBufferPool with the specified maximum buffer pool size and a maximum size for each individual buffer in the pool.

the maximum size to allow for the buffer pool the maximum size to allow for each individual buffer in the pool There was insufficient memory to create the requested buffer pool. Either maxBufferPoolSize or maxBufferSize was less than zero.

Return a byte-array buffer of at least the specified size from the pool.

the size in bytes of the requested buffer a byte-array that is the requested size size cannot be less than zero

Return the given buffer to this manager pool.

a reference to the buffer being returned the Length of buffer does not match the pool's buffer length property the buffer reference cannot be null

Release the buffers currently cached in this manager.

true if managed resources are to be disposed

This simple implementation of does no buffer pooling. Instead, it uses regular .NET memory management to allocate a buffer each time is called. Unused buffers passed to are simply left for the .NET garbage collector to deal with.

Return a newly-allocated byte-array buffer of at least the specified size from the pool.

the size in bytes of the requested buffer a byte-array that is the requested size there is not sufficient memory to allocate the requested memory

The expectation of an actual buffer-manager is that this method returns the given buffer to the manager pool. This particular implementation does nothing.

a reference to the buffer being returned

The expectation of an actual buffer-manager is that the Dispose method will release the buffers currently cached in this manager. This particular implementation does nothing.

Release the buffers currently cached in this manager (however in this case, this does nothing).

true if managed resources are to be disposed

Contains a singleton instance of used for allocating byte arrays for instances with type .

Sending and receiving message frames requires the use of buffers (byte arrays), which are expensive to create and destroy. You can use the BufferPool class to pool buffers for reuse, reducing allocation, deallocation and garbage collection. The default implementation is . Call to replace it with a . Call to reinstate the default . Call to substitute a custom implementation for the allocation and deallocation of message buffers.

Set BufferPool to use the (which it does by default).

Set BufferPool to use the to manage the buffer-pool.

Set BufferPool to use the specified IBufferPool implementation to manage the buffer-pool.

the implementation of to use

Allocate a buffer of at least bytes from the current .

The minimum size required, in bytes. A byte array having at least bytes.

Returns to the .

The byte array to be returned to the pool.

Class Address contains a specification of a protocol and an MqEndPoint.

The string-literal "inproc" - this denotes in-process, or inter-thread, communication.

The string-literal "tcp" - this denotes TCP communication over the network.

The string-literal "ipc" - this denotes inter-process communication, which on NetMQ is exactly the same as TCP.

The string-literal "pgm" - this denotes the Pragmatic General Multicast (PGM) reliable multicast protocol.

The string-literal "epgm" - this denotes the Encapsulated PGM protocol.

Create a new Address instance with the given protocol and text expression of an address.

the protocol of this Address - as in tcp, ipc, pgm a text representation of the address

Create a new Address instance based upon the given endpoint, assuming a protocol of tcp.

the subclass of EndPoint to base this Address upon

Interface IZAddress specifies that Resolve and property Address must be implemented.

Defines a command sent between threads.

Create a new Command object for the given destination, type, and optional argument.

a ZObject that denotes the destination for this command the CommandType of the new command an Object to comprise the argument for the command (optional)

Override of ToString, which returns a string in the form [ command-type, destination ].

a string that denotes the command-type and destination

The destination to which the command should be applied.

The type of this command.

Get the argument to this command.

Enumeration of possible types.

The value of denotes what action the command will perform.

Sent to I/O thread to let it know that it should terminate itself.

Sent to I/O object to make it register with its I/O thread

Sent to socket to let it know about the newly created object.

Attach the engine to the session. If engine is NULL, it informs session that the connection has failed.

Sent from session to socket to establish pipe(s) between them. Caller must have used inc_seqnum before sending the command.

Sent by pipe writer to inform dormant pipe reader that there are messages in the pipe.

Sent by pipe reader to inform pipe writer how many messages it has read so far.

Sent by pipe reader to writer after creating a new inpipe. The parameter is actually of type pipe_t::upipe_t, however, its definition is private so we'll have to do with void*.

Sent by pipe reader to pipe writer to ask it to terminate its end of the pipe.

Pipe writer acknowledges pipe_term command.

Sent by I/O object to the socket to request the shutdown of the I/O object.

Sent by socket to I/O object to start its shutdown.

Sent by I/O object to the socket to acknowledge it has shut down.

Transfers the ownership of the closed socket to the reaper thread.

Closed socket notifies the reaper that it's already deallocated.

Sent by reaper thread to the term thread when all the sockets have successfully been deallocated.

Send to reaper to stop the reaper immediatly

This class exists to hold constant values that comprise the internal configuration of the messaging system.

Number of new messages in message pipe needed to trigger new memory allocation. Setting this parameter to 256 decreases the impact of memory allocation by approximately 99.6%

Commands in pipe per allocation event.

Determines how often does socket poll for new commands when it still has unprocessed messages to handle. Thus, if it is set to 100, socket will process 100 inbound messages before doing the poll. If there are no unprocessed messages available, poll is done immediately. Decreasing the value trades overall latency for more real-time behaviour (less latency peaks).

Maximal batching size for engines with receiving functionality. So, if there are 10 messages that fit into the batch size, all of them may be read by a single 'recv' system call, thus avoiding unnecessary network stack traversals.

Maximal batching size for engines with sending functionality. So, if there are 10 messages that fit into the batch size, all of them may be written by a single 'send' system call, thus avoiding unnecessary network stack traversals.

Maximal delta between high and low watermark.

Maximum number of events the I/O thread can process in one go.

Maximal delay to process command in API thread (in CPU ticks). 3,000,000 ticks equals to 1 - 2 milliseconds on current CPUs. Note that delay is only applied when there is continuous stream of messages to process. If not so, commands are processed immediately.

Low-precision clock precision in CPU ticks. 1ms. Value of 1000000 should be OK for CPU frequencies above 1GHz. If should work reasonably well for CPU frequencies above 500MHz. For lower CPU frequencies you may consider lowering this value to get best possible latencies.

Maximum transport data unit size for PGM (TPDU).

On some OSes the signaler has to be emulated using a TCP connection. In such cases following port is used.

Objects of class Ctx are intended to encapsulate all of the global state associated with the NetMQ library. This contains the sockets, and manages interaction between them.

Internal analog of the public class.

The thread-id for the termination (the equivalent of the zmq_term) thread.

This is the thread-id to assign to the Reaper (value is 1).

Sockets belonging to this context. We need the list so that we can notify the sockets when zmq_term() is called. The sockets will return ETERM then.

List of unused thread slots.

If true, zmq_init has been called but no socket has been created yet. Launching of I/O threads is delayed.

If true, zmq_term was already called.

This object is for synchronisation of accesses to global slot-related data: sockets, empty_slots, terminating. It also synchronises access to zombie sockets as such (as opposed to slots) and provides a memory barrier to ensure that all CPU cores see the same data.

The reaper thread.

List of I/O threads.

Length of the mailbox-array.

Array of pointers to mailboxes for both application and I/O threads.

Mailbox for zmq_term thread.

Dictionary containing the inproc endpoints within this context.

This object provides synchronisation of access to the list of inproc endpoints.

The highest socket-id that has been assigned thus far.

The maximum number of sockets that can be opened at the same time.

The number of I/O threads to launch.

Should the context termination block until all socket are disposed?

This object is used to synchronize access to context options.

Throws if this is already disposed.

This object has already been disposed.

This function is called when user invokes zmq_term. If there are no more sockets open it'll cause all the infrastructure to be shut down. If there are open sockets still, the deallocation happens after the last one is closed.

Create and return a new socket of the given type, and initialize this Ctx if this is the first one.

the type of socket to create the newly-created socket Cannot create new socket while terminating. Maximum number of sockets reached. The context (Ctx) must not be already terminating.

Destroy the given socket - which means to remove it from the list of active sockets, and add it to the list of unused sockets to be terminated.

the socket to destroy If this was the last socket, then stop the reaper.

Returns reaper thread object.

Send a command to the given destination thread.

Returns the that is the least busy at the moment.

Which threads are eligible (0 = all). The least busy thread, or null if none is available.

Save the given address and Endpoint within our internal list. This is used for management of inproc endpoints.

the textual name to give this endpoint the Endpoint to remember true if the given address was NOT already registered

Un-register the given address/socket, by removing it from the contained list of endpoints.

the (string) address denoting the endpoint to unregister the socket associated with that endpoint true if the endpoint having this address and socket is found, false otherwise

Remove from the list of endpoints, all endpoints that reference the given socket.

the socket to remove all references to

Return the EndPoint that has the given address, and increments the seqnum of the associated socket.

the (string) address to match against the endpoints the Endpoint that was found The given address was not found in the list of endpoints. By calling this method, the socket associated with that returned EndPoint has it's Seqnum incremented, in order to prevent it from being de-allocated before a command can be sent to it.

Should context wait for all sockets before terminating?

Information associated with inproc endpoint. Note that endpoint options are registered as well so that the peer can access them without a need for synchronisation, handshaking or similar.

Create a new Endpoint with the given socket.

the socket for this new Endpoint the Options to assign to this new Endpoint

Get the socket associated with this Endpoint.

Get the Options of this Endpoint.

Class ErrorHelper provides one static method - ToErrorCode, for converting a SocketError to the equivalent ErrorCode.

Return the ErrorCode that is the closest equivalent to the given SocketError.

the SocketError to convert from an ErrorCode that corresponds to the given SocketError

Interface IMsgSink mandates a PushMsg( Msg ) method.

Deliver a message. Return true if successful; false otherwise. This function takes ownership of the passed message.

the message (of type Msg) to deliver

Classes that implement IMsgSource are able to fetch a message, with the method: PullMsg.

Fetch a message. If successful - returns true and writes the message instance to the msg argument. If not successful - return false and write null to the msg argument.

the Msg to write the fetched message into true if successful - and writes the message to the msg argument

Simple base class for objects that live in I/O threads. It makes communication with the poller object easier and makes defining unneeded event handlers unnecessary.

This is an ITimerEvent, with InCompleted and OutCompleted callback-methods, used for implementing a Proactor pattern.

The ITimerEvent interface mandates a TimerEvent( int id ) method, that is called with an id-value when the timer expires.

This is called when the timer expires.

an integer used to identify the timer

This is the "Input-Completed" method - called by the I/O-thread when the file descriptor is ready for reading.

this is set to any socket-error that has occurred the number of bytes that are now ready to be read

This is the "Output-Completed" method - called by the I/O thread when the file descriptor is ready for writing.

this is set to any socket-error that has occurred the number of bytes that are now ready to be written

Create a new IOObject object and plug it into the given IOThread.

the IOThread to plug this new IOObject into.

"Plug in" this IOObject to the given IOThread, - ie associate this with the specified IOThread.

the IOThread for this object to live in When migrating an object from one I/O thread to another, first unplug it, then migrate it, then plug it to the new thread.

"Un-Plug" this IOObject from its current IOThread, and set its handler to null.

When migrating an object from one I/O thread to another, first unplug it, then migrate it, then plug it to the new thread.

Add the given socket to the Proactor.

the AsyncSocket to add

Remove the given socket from the Proactor.

the AsyncSocket to remove

This method is called when a message receive operation has been completed. This forwards it on to the handler's InCompleted method.

a SocketError value that indicates whether Success or an error occurred the number of bytes that were transferred

This method is called when a message Send operation has been completed. This forwards it on to the handler's OutCompleted method.

a SocketError value that indicates whether Success or an error occurred the number of bytes that were transferred

This is called when the timer expires.

an integer used to identify the timer

This is the base-class for all objects that participate in inter-thread communication.

This Ctx is the context that provides access to the global state.

This is the thread-ID of the thread that this object belongs to.

Create a new ZObject with the given context and thread-id.

the context for the new ZObject to live within the integer thread-id for the new ZObject to be associated with

Create a new ZObject that has the same context and thread-id as the given parent-ZObject.

another ZObject that provides the context and thread-id for this one The given address was not found in the list of endpoints.

Returns the that is the least busy at the moment.

Which threads are eligible (0 = all). The least busy thread, or null if none is available.

Send the Stop command.

Send the Plug command, incrementing the destinations sequence-number if incSeqnum is true.

the Own to send the command to a flag that dictates whether to increment the sequence-number on the destination (optional - defaults to false)

Send the Own command, and increment the sequence-number of the destination

the Own to send the command to the object to Own

Send the Attach command

the Own to send the command to

Send the Bind command

For owned objects, asks the owner () to terminate .

Send a Done command to the Ctx itself (null destination).

Send the given Command, on that commands Destination thread.

the Command to send Not supported on the ZObject class. Not supported on the ZObject class. Not supported on the ZObject class. Not supported on the ZObject class. Not supported on the ZObject class.

Process the bind command with the given pipe.

Not supported on the ZObject class. Not supported on the ZObject class. Not supported on the ZObject class.

This method would be called to assign the specified pipe as a replacement for the outbound pipe that was being used. This, is an abstract method that is to be overridden by subclasses to provide their own concrete implementation.

the pipe to use for writing A "Hiccup" occurs when an outbound pipe experiences something like a transient disconnect or for whatever other reason is no longer available for writing to. No supported on the ZObject class.

Process the terminate-pipe command.

Not supported on the ZObject class.

Process the terminate-pipe acknowledgement command.

Not supported on the ZObject class.

Process a termination-request command on the Own object.

Not supported on the ZObject class.

Process a termination request.

a time (in milliseconds) for this to linger before actually going away. -1 means infinite. Not supported on the ZObject class.

Process the termination-acknowledgement command.

Not supported on the ZObject class. Not supported on the ZObject class.

Special handler called after a command that requires a seqnum was processed. The implementation should catch up with its counter of processed commands here.

Not supported on the ZObject class.

Get the id of the thread that this object belongs to.

Get the context that provides access to the global state.

I/O thread accesses incoming commands via this mailbox.

I/O multiplexing is performed using a poller object.

Create a new IOThread object within the given context (Ctx) and thread.

the Ctx (context) for this thread to live within the integer thread-id for this new IOThread

Classes that implement IPollEvents provide two methods (InEvent and OutEvent) that are invoked when ready for reading or writing.

Called by the I/O thread when the file descriptor is ready for reading.

Called by the I/O thread when the file descriptor is ready for writing.

There's only one thread receiving from the mailbox, but there is arbitrary number of threads sending. Given that ypipe requires synchronised access on both of its endpoints, we have to synchronize the sending side.

The pipe to store actual commands.

Signaler to pass signals from writer thread to reader thread.

There's only one thread receiving from the mailbox, but there is an arbitrary number of threads sending. Given that requires synchronised access on both of its endpoints, we have to synchronize the sending side.

True if the underlying pipe is active, ie. when we are allowed to read commands from it.

Create a new Mailbox with the given name.

the name to give this new Mailbox

Send the given Command out accross the command-pipe.

the Command to send

Receive and return a Command from the command-pipe.

how long to wait for a command (in milliseconds) before returning

Close the contained Signaler.

Get the socket-handle contained by the Signaler.

Class Options is essentially a container for socket-related option-settings.

Create a new Options object with all default values.

Assign the given optionValue to the specified option.

a ZmqSocketOption that specifies what to set an Object that is the value to set that option to The option and optionValue must be valid.

Get the value of the specified option.

a ZmqSocketOption that specifies what to get an Object that is the value of that option A valid option must be specified.

Get or set the I/O-thread affinity. The default value is 0.

Maximum backlog for pending connections. The default value is 100.

Get or set whether connecting pipes are not attached immediately, meaning a send() on a socket with only connecting pipes would block. The default value is false.

If true, session reads all the pending messages from the pipe and sends them to the network when socket is closed. The default value is true.

If true, socket reads all the messages from the pipe and delivers them to the user when the peer terminates. The default value is true.

Get or set the Endian-ness, which indicates whether the most-significant bits are placed higher or lower in memory. The default value is Endianness.Big.

If true, (X)SUB socket should filter the messages. If false (which is the default), it should not.

Get or set the byte-array that represents the Identity. The initial value is null.

Get or set the size of the socket-identity byte-array. The initial value is 0, until the Identity property is set.

Get or set whether this allows the use of IPv4 sockets only. If true (the default), it will not be possible to communicate with IPv6-only hosts. If false, the socket can connect to and accept connections from both IPv4 and IPv6 hosts.

Get or set the last socket endpoint resolved URI The initial value is null.

Get or set the Linger time, in milliseconds. The default value is -1; The XSub ctor sets this to 0.

Get or set the maximum size of message to handle. The default value is -1, which indicates no limit.

Get or set the maximum size of message to handle.

Sets the time-to-live field in every multicast packet sent. The default value is 1.

Get or set the maximum transfer rate [Kb/s]. The default is 100 Kb/s.

If true, router socket accepts non-zmq tcp connections The default value is false, except the Stream ctor initialises this to true.

If true, the identity message is forwarded to the socket. The default value is false.

Get or set the minimum interval between attempts to reconnect, in milliseconds. The default is 100 ms

Get or set the maximum interval between attempts to reconnect, in milliseconds. The default is 0 (unused).

Get or set the recovery time interval [ms]. The default is 10 seconds.

SO_SNDBUF and SO_RCVBUF to be passed to underlying transport sockets. The initial value is 0.

Get or set the size of the receive-buffer. The initial value is 0.

Get or set the high-water marks for message pipes. The default value is 1000.

Get or set the high-water mark for message reception. The default value is 1000.

Get or set the timeout for send operations for this socket. The default value is -1, which means no timeout.

Get or set the timeout for receive operations for this socket. The default value is -1, which means no timeout.

Get or set the ID of the socket. The default value is 0.

Get or set the type of socket (ZmqSocketType). The default value is ZmqSocketType.None.

TCP keep-alive settings. Defaults to -1 = do not change socket options

Get or set the TCP Keep-Alive Count. The default value is -1.

Get or set the TCP Keep-Alive interval to use when at idle. The default value is -1.

Get or set the TCP Keep-Alive Interval The default value is -1.

Disable TIME_WAIT tcp state when client disconnect. The default value is false.

Base class for objects forming a part of ownership hierarchy. It handles initialisation and destruction of such objects.

The Options of this Own.

True if termination was already initiated. If so, we can destroy the object if there are no more child objects or pending term acks.

Sequence number of the last command sent to this object.

Sequence number of the last command processed by this object.

Socket owning this object. It's responsible for shutting down this object.

List of all objects owned by this socket. We are responsible for deallocating them before we quit.

Number of events we have to get before we can destroy the object.

Initializes a new instance of the class that is running on a thread outside of 0MQ infrastructure.

The parent context. The thread id. Note that the owner is unspecified in the constructor. It'll be assigned later on using when the object is plugged in.

Initializes a new instance of the class that is running within I/O thread.

The I/O thread. The options. Note that the owner is unspecified in the constructor. It'll be assigned later on using when the object is plugged in.

Eliminate any contained resources that need to have this explicitly done.

A place to hook in when physical destruction of the object is to be delayed. Unless overridden, this simply calls Destroy.

Set the owner of *this* Own object, to be the given owner.

the Own object to be our new owner

When another owned object wants to send a command to this object it calls this function to let it know it should not shut down before the command is delivered.

This function may be called from a different thread!

Launch the supplied object and become its owner.

The object to be launched.

Terminate owned object.

Process a termination-request for the given Own obj, removing it from the listed of owned things.

the Own object to remove and terminate

Add the given Own object to the list of owned things.

the Own object to add to our list If *this* Own is already terminating, then send a request to the given Own obj to terminate itself.

Ask owner object to terminate this object. It may take a while actual termination is started.

This function should not be called more than once.

Send termination requests to all of the owned objects, and then runs the termination process.

the linger time, in milliseconds Termination handler is protected rather than private so that it can be intercepted by the derived class. This is useful to add custom steps to the beginning of the termination process.

Add the given number to the termination-acknowledgement count.

The methods RegisterTermAcks and are used to wait for arbitrary events before terminating. Just add the number of events to wait for, and when the event occurs - call . When the number of pending termination-acknowledgements reaches zero, this object will be deallocated.

Decrement the termination-acknowledgement count, and if it reaches zero then send a termination-ack to the owner.

The methods and UnregisterTermAck are used to wait for arbitrary events before terminating. Just add the number of events to wait for, and when the event occurs - call UnregisterTermAck. When the number of pending termination-acknowledgements reaches zero, this object will be deallocated.

Process the first termination-acknowledgement. Unless this is overridden, it simply calls .

If terminating, and we've already worked through the Seq-nums that were sent, then send a termination-ack to the owner (if there is one) and destroy itself.

Returns true if the object is in process of termination.

A Dealer socket is a SocketBase that is used as the parent-class of the Req socket. It provides for a pre-fetched Msg, and skips identity-messages.

A pipe is a ZObject with ..

Note that pipe can be stored in three different arrays. The array of inbound pipes (1), the array of outbound pipes (2) and the generic array of pipes to deallocate (3).

The underlying pipe for reading from.

The underlying pipe for writing to.

This indicates whether this pipe can be read from.

This indicates whether this pipe be written to.

High watermark for the outbound pipe.

Low watermark for the inbound pipe.

Number of messages read so far.

Number of messages written so far.

Last received peer's msgs_read. The actual number in the peer can be higher at the moment.

The pipe object on the other side of the pipe-pair.

Sink to send events to.

If true, we receive all the pending inbound messages before terminating. If false, we terminate immediately when the peer asks us to.

Identity of the writer. Used uniquely by the reader side.

Create a new Pipe object with the given parent, and inbound and outbound YPipes.

Constructor is private as pipe can only be created using method.

Create a pipe pair for bi-directional transfer of messages.

The parents. First HWM is for messages passed from first pipe to the second pipe. Second HWM is for messages passed from second pipe to the first pipe. Delay specifies how the pipe behaves when the peer terminates. If true pipe receives all the pending messages before terminating, otherwise it terminates straight away. A pipe pair for bi-directional transfer of messages.

uses this function to let us know about the peer pipe object.

The peer to be assigned.

Specifies the object to send events to.

The receiver of the events.

Checks if there is at least one message to read in the pipe.

Returns true if there is at least one message to read in the pipe; false otherwise.

Read a message from the underlying inbound pipe, and write it to the provided Msg argument.

true if a message is read from the pipe, false if pipe is terminated or no messages are available

Check whether messages can be written to the pipe. If writing the message would cause high watermark the function returns false.

true if message can be written to the pipe; false otherwise.

Write a message to the underlying pipe.

The message to write. false if the message cannot be written because high watermark was reached.

Remove unfinished parts of the outbound message from the pipe.

Flush the messages downstream.

This method is called to assign the specified pipe as a replacement for the outbound pipe that was being used.

the pipe to use for writing A "Hiccup" occurs when an outbound pipe experiences something like a transient disconnect or for whatever other reason is no longer available for writing to.

Process the pipe-termination ack.

Ask pipe to terminate. The termination will happen asynchronously and user will be notified about actual deallocation by 'terminated' event.

if set to true, the pending messages will be processed before actual shutdown.

Compute an appropriate low watermark from the given high-watermark.

the given high-watermark value to compute it from the computed low-watermark

Handles the delimiter read from the pipe.

Temporarily disconnects the inbound message stream and drops all the messages on the fly. Causes 'hiccuped' event to be generated in the peer.

Override the ToString method to return a string denoting the type and the parent.

a string containing this type and also the value of the parent-property

Get or set the byte-array that comprises the identity of this Pipe.

Indicate that the given pipe is now ready for reading. Pipe calls this on it's sink in response to ProcessActivateRead. When called upon an instance of SocketBase, this simply calls XReadActivated.

the pipe to indicate is ready for reading

This gets called by ProcessPipeTermAck or XTerminated to respond to the termination of the given pipe.

the pipe that was terminated

Specifies the state of the pipe endpoint.

Active is common state before any termination begins.

Delimited means that delimiter was read from pipe before term command was received.

Pending means that term command was already received from the peer but there are still pending messages to read.

Terminating means that all pending messages were already read and all we are waiting for is ack from the peer.

Terminated means that 'terminate' was explicitly called by the user.

Double_terminated means that user called 'terminate' and then we've got term command from the peer as well.

If true, associated context was already terminated.

If true, object should have been already destroyed. However, destruction is delayed while we unwind the stack to the point where it doesn't intersect the object being destroyed.

Socket's mailbox object.

List of attached pipes.

Reaper's poller.

The handle of this socket within the reaper's poller.

Timestamp of when commands were processed the last time.

Number of messages received since last command processing.

True if the last message received had MORE flag set.

Monitor socket.

Bitmask of events being monitored.

The tcp port that was bound to, if any.

Create a new SocketBase within the given Ctx, with the specified thread-id and socket-id.

the Ctx context that this socket will live within the id of the thread upon which this socket will execute the integer id for the new socket

Abstract method for attaching a given pipe to this socket. The concrete implementations are defined by the individual socket types.

the Pipe to attach if true - subscribe to all data on the pipe

Abstract method that gets called to signal that the given pipe is to be removed from this socket. The concrete implementations of SocketBase override this to provide their own implementation of how to terminate the pipe.

the Pipe that is being removed

Throw if this socket is already disposed.

This object is already disposed.

Throw if the message-queueing system has started terminating.

The socket has been stopped.

Create a socket of a specified type.

a ZmqSocketType specifying the type of socket to create the parent context the thread for this new socket to run on an integer id for this socket The socket type must be valid.

Destroy this socket - which means to stop monitoring the queue for messages. This simply calls StopMonitor, and then verifies that the destroyed-flag is set.

Interrupt a blocking call if the socket is stuck in one. This function can be called from a different thread!

Check whether the transport protocol, as specified in connect or bind, is available and compatible with the socket type.

the specified protocol is not supported the socket type and protocol do not match The supported protocols are "inproc", "ipc", "tcp", "pgm", and "epgm". If the protocol is either "pgm" or "epgm", then this socket must be of type Pub, Sub, XPub, or XSub.

the Pipe to attach if true - subscribe to all data on the pipe (optional - default is false)

Set the specified socket option.

which option to set the value to set the option to The socket has been stopped.

Return the integer-value of the specified option.

which option to get the value of the specified option, or -1 if error The socket has been stopped. If the ReceiveMore option is specified, then 1 is returned if it is true, 0 if it is false. If the Events option is specified, then process any outstanding commands, and return -1 if that throws a TerminatingException. then return an integer that is the bitwise-OR of the PollEvents.PollOut and PollEvents.PollIn flags. Otherwise, cast the specified option value to an integer and return it.

Return the value of the specified option as an Object.

which option to get the value of the option The socket has already been stopped. If the Handle option is specified, then return the handle of the contained mailbox. If the Events option is specified, then process any outstanding commands, and return -1 if that throws a TerminatingException. then return a PollEvents that is the bitwise-OR of the PollEvents.PollOut and PollEvents.PollIn flags.

Bind this socket to the given address.

a string denoting the endpoint-address to bind to the address specified to bind to must not be already in use The requested protocol is not supported. the socket bind failed No IO thread was found, or the protocol's listener encountered an error during initialisation. the specified protocol is not supported the socket type and protocol do not match The socket has been stopped. The supported protocols are "inproc", "ipc", "tcp", "pgm", and "epgm". If the protocol is either "pgm" or "epgm", then this socket must be of type Pub, Sub, XPub, or XSub. If the protocol is "inproc", you cannot bind to the same address more than once.

Bind the specified TCP address to an available port, assigned by the operating system.

a string denoting the endpoint to bind to the port-number that was bound to uses a protocol other than TCP. The socket has been stopped. The specified address is already in use. No IO thread was found, or the protocol's listener errored during initialisation. the socket bind failed

Connect this socket to the given address.

a string denoting the endpoint to connect to The specified address is already in use. No IO thread was found. the specified protocol is not supported the socket type and protocol do not match The socket has been stopped. The supported protocols are "inproc", "ipc", "tcp", "pgm", and "epgm". If the protocol is either "pgm" or "epgm", then this socket must be of type Pub, Sub, XPub, or XSub. The given address was not found in the list of endpoints.

Given a string containing an endpoint address like "tcp://127.0.0.1:5555, break-it-down into the address part ("127.0.0.1:5555") and the protocol part ("tcp").

a string denoting the endpoint, to take the parts from the IP-address portion of the end-point address the protocol portion of the end-point address (such as "tcp")

Take ownership of the given and register it against the given .

Disconnect from the given endpoint.

the endpoint to disconnect from is null. Endpoint was not found and cannot be disconnected. The specified protocol must be valid. The socket has been stopped.

Transmit the given Msg across the message-queueing system.

The to send. The timeout to wait before returning false. Pass to disable timeout. Whether this message will contain another frame after this one. The socket has been stopped. is not initialised.

Receive a frame into the given and return true if successful, false if it timed out.

the Msg to read the received message into this controls whether the call blocks, and for how long. true if successful, false if it timed out For , there are three categories of value: - return false immediately if no message is available (or a negative value) - wait indefinitely, always returning true Any positive value - return false after the corresponding duration if no message has become available the Msg must already have been uninitialised The socket must not already be stopped.

Close this socket. Mark it as disposed, and send ownership of it to the reaper thread to attend to the rest of it's shutdown process.

These functions are used by the polling mechanism to determine which events are to be reported from this socket.

Using this function reaper thread ask the socket to register with its poller.

Processes commands sent to this socket (if any). If is -1, the call blocks until at least one command was processed. If is true, commands are processed at most once in a predefined time period.

how much time to allow to wait for a command, before returning (in milliseconds) if true - throttle the rate of command-execution by doing only one per call The Ctx context must not already be terminating.

Process a termination command on this socket, by stopping monitoring and marking this as terminated.

Process a Bind command by attaching the given Pipe.

the Pipe to attach

Process a termination request.

a time (in milliseconds) for this to linger before actually going away. -1 means infinite.

Mark this socket as having been destroyed. Delay actual destruction of the socket.

The default implementation assumes there are no specific socket options for the particular socket type. If not so, overload this method.

a ZmqSocketOption specifying which option to set an Object that is the value to set the option to

This gets called when outgoing messages are ready to be sent out. On SocketBase, this does nothing and simply returns false.

this method on SocketBase only returns false

Transmit the given message. The method calls this to do the actual sending. This abstract method gets overridden by the different socket types to provide their concrete implementation of sending messages.

the message to transmit true if the message was sent successfully

This gets called when incoming messages are ready to be received. On SocketBase, this does nothing and simply returns false.

this method on SocketBase only returns false

Receive a message. The Recv method calls this lower-level method to do the actual receiving. This abstract method gets overridden by the different socket types to provide their concrete implementation of receiving messages.

the Msg to receive the message into true if the message was received successfully, false if there were no messages to receive

Indicate the given pipe as being ready for reading by this socket. This abstract method gets overridden by the different sockets to provide their own concrete implementation.

the Pipe that is now becoming available for reading

Indicate the given pipe as being ready for writing to by this socket. This abstract method gets called by the WriteActivated method and gets overridden by the different sockets to provide their own concrete implementation.

the Pipe that is now becoming available for writing

Handle input-ready events by receiving and processing any incoming commands.

Handle output-ready events.

This is not supported on instances of the parent class SocketBase.

In subclasses of SocketBase this is overridden, to handle the expiration of a timer.

an integer used to identify the timer You must not call TimerEvent on an instance of class SocketBase.

To be called after processing commands or invoking any command handlers explicitly. If required, it will deallocate the socket.

Indicate that the given pipe is now ready for reading. Pipe calls this on it's sink in response to ProcessActivateRead. When called upon an instance of SocketBase, this simply calls XReadActivated.

the pipe to indicate is ready for reading

When called upon an instance of SocketBase, this simply calls XWriteActivated.

the pipe to indicate is ready for writing

This gets called by ProcessPipeTermAck or XTerminated to respond to the termination of the given pipe.

the pipe that was terminated

Moves the flags from the message to local variables, to be later retrieved by getsockopt.

a string denoting the endpoint to monitor. If this is null - monitoring is stopped. the SocketEvent to monitor for Maximum number of sockets reached. The protocol of is not supported. The socket has been stopped.

If there is a monitor-socket, close it and set monitor-events to 0.

Override the ToString method in order to also show the socket-id.

A string that denotes this object type followed by [ socket-id ]

Return a short bit of text that denotes the SocketType of this socket.

a short type-string such as PAIR, PUB, OR UNKNOWN

Return the Mailbox associated with this socket.

Get the Socket (Handle) - which is actually the Handle of the contained mailbox.

Messages are fair-queued from inbound pipes. And load-balanced to the outbound pipes.

Have we prefetched a message.

The Msg that we have pre-fetched.

Create a new Dealer socket that holds the prefetched message.

Destroy this Dealer-socket and close out any pre-fetched Msg.

the Pipe to attach not used

Transmit the given message. The Send method calls this to do the actual sending.

the message to transmit true if the message was sent successfully

For a Dealer socket: If there's a pre-fetched message, snatch that. Otherwise, dump any identity messages and get the first non-identity message, or return false if there are no messages available.

a Msg to receive the message into true if the message was received successfully, false if there were no messages to receive

If there's a pre-fetched message, snatch that. Otherwise, dump any identity messages and get the first non-identity message, or return false if there are no messages available.

a Msg to receive the message into false if there were no messages to receive

If there is a message available and one has not been pre-fetched yet, preserve that message as our pre-fetched one.

Indicate the given pipe as being ready for reading by this socket.

the Pipe that is now becoming available for reading

Indicate the given pipe as being ready for writing to by this socket. This gets called by the WriteActivated method and gets overridden by the different sockets to provide their own concrete implementation.

the Pipe that is now becoming available for writing

This is an override of the abstract method that gets called to signal that the given pipe is to be removed from this socket.

the Pipe that is being removed

A DealerSession is a SessionBase subclass that is contained within the Dealer class.

ID of the linger timer (0x20)

If true, this session (re)connects to the peer. Otherwise, it's a transient session created by the listener.

Pipe connecting the session to its socket.

This set is added to with pipes we are disconnecting, but haven't yet completed

This flag is true if the remainder of the message being processed is still in the pipe.

True if termination have been suspended to push the pending messages to the network.

The protocol I/O engine connected to the session.

The socket the session belongs to.

I/O thread the session is living in. It will be used to plug in the engines into the same thread.

True is linger timer is running.

If true, identity has been sent to the network.

If true, identity has been received from the network.

Protocol and address to use when connecting.

Create a return a new session. The specific subclass of SessionBase that is created is dictated by the SocketType specified by the options argument.

the IOThread for this session to run in whether to immediately connect the socket to connect an Options that provides the SocketType that dictates which type of session to create an Address object that specifies the protocol and address to connect to the newly-created instance of whichever subclass of SessionBase is specified by the options The socket must be of the correct type.

Create a new SessionBase object from the given IOThread, socket, and Address.

the IOThread for this session to run on this flag dictates whether to connect the socket to contain Options that dictate the settings of this session an Address that dictates the protocol and IP-address to use when connecting

Terminate and release any contained resources. This cancels the linger-timer if that exists, and terminates the protocol-engine if that exists.

Attach the given pipe to this session.

This is to be used once only, when creating the session.

Read a message from the pipe.

a reference to a Msg to put the message into true if the Msg is successfully sent

Write the given Msg to the pipe.

the Msg to push to the pipe true if the Msg was successfully sent

Set the identity-sent and identity-received flags to false.

Flush any messages that are in the pipe downstream.

Remove any half processed messages. Flush unflushed messages. Call this function when engine disconnect to get rid of leftovers.

This gets called by ProcessPipeTermAck or XTerminated to respond to the termination of the given pipe.

the pipe that was terminated

Indicate that the given pipe is now ready for reading. Pipe calls this on it's sink in response to ProcessActivateRead.

the pipe to indicate is ready for reading

Process the Plug-request by setting this SessionBase as teh handler for the io-object and starting connecting (without waiting).

Process the Attach-request by hooking up the pipes and plugging in the given engine.

the IEngine to plug in

Flush out any leftover messages and call Detached.

Process a termination request.

a time (in milliseconds) for this to linger before actually going away. -1 means infinite.

Call this function to move on with the delayed process-termination request.

This is called when the timer expires.

an integer used to identify the timer

The parent SessionBase class calls this when the Detach method finishes detaching.

Begin connecting.

Whether to wait a bit before actually attempting to connect

Override the ToString method to also show the socket-id.

the type of this object and [ socket-id ]

This method would be called when a message receive operation has been completed, although here it only throws a NotSupportedException.

a SocketError value that indicates whether Success or an error occurred the number of bytes that were transferred This operation is not supported on the SessionBase class.

This method would be called when a message Send operation has been completed, although here it only throws a NotSupportedException.

a SocketError value that indicates whether Success or an error occurred the number of bytes that were transferred This operation is not supported on the SessionBase class.

Get the contained socket.

Create a new DealerSession (which is just a SessionBase).

the I/O-thread to associate this with

the Pipe to attach not used

This is an override of the abstract method that gets called to signal that the given pipe is to be removed from this socket.

the Pipe that is being removed

Indicate the given pipe as being ready for reading by this socket - however in the case of Pair, this does nothing.

the Pipe that is now becoming available for reading

Indicate the given pipe as being ready for writing to by this socket, however in the case of this Pair socket - this does nothing. This method gets called by the WriteActivated method.

the Pipe that is now becoming available for writing

Transmit the given message. The Send method calls this to do the actual sending.

the message to transmit true if the message was sent successfully

Receive a message. The Recv method calls this lower-level method to do the actual receiving.

the Msg to receive the message into true if the message was received successfully, false if there were no messages to receive

List of all subscriptions mapped to corresponding pipes.

Distributor of messages holding the list of outbound pipes.

If true, send all subscription messages upstream, not just unique ones. The default is false.

The default value is false.

True if we are in the middle of sending a multipart message.

List of pending (un)subscriptions, ie. those that were already applied to the trie, but not yet received by the user.

the Pipe to attach if true - subscribe to all data on the pipe

Indicate the given pipe as being ready for reading by this socket.

the Pipe that is now becoming available for reading

Indicate the given pipe as being ready for writing to by this socket. This gets called by the WriteActivated method.

the Pipe that is now becoming available for writing

Set the specified option on this socket.

which option to set the value to set the option to true if successful optionValue must be a byte-array.

This is an override of the abstract method that gets called to signal that the given pipe is to be removed from this socket.

the Pipe that is being removed

Transmit the given message. The Send method calls this to do the actual sending.

the message to transmit true if the message was sent successfully

Receive a message. The Recv method calls this lower-level method to do the actual receiving.

the Msg to receive the message into true if the message was received successfully, false if there were no messages to receive

This override of the abstract XRecv method, simply throws a NotSupportedException because XRecv is not supported on a Pub socket.

the Msg to receive the message into Messages cannot be received from PUB socket

Fair queueing object for inbound pipes.

the Pipe to attach not used

Indicate the given pipe as being ready for reading by this socket.

the Pipe that is now becoming available for reading

This is an override of the abstract method that gets called to signal that the given pipe is to be removed from this socket.

the Pipe that is being removed

Receive a message. The Recv method calls this lower-level method to do the actual receiving.

the Msg to receive the message into true if the message was received successfully, false if there were no messages to receive

Load balancer managing the outbound pipes.

the Pipe to attach not used

Indicate the given pipe as being ready for writing to by this socket. This gets called by the WriteActivated method.

the Pipe that is now becoming available for writing

This is an override of the abstract method that gets called to signal that the given pipe is to be removed from this socket.

the Pipe that is being removed

Transmit the given message. The Send method calls this to do the actual sending.

the message to transmit true if the message was sent successfully

A Router is a subclass of SocketBase

Fair queueing object for inbound pipes.

True if there is a message held in the pre-fetch buffer.

If true, the receiver got the message part with the peer's identity.

Holds the prefetched identity.

Holds the prefetched message.

If true, more incoming message parts are expected.

We keep a set of pipes that have not been identified yet.

Outbound pipes indexed by the peer IDs.

The pipe we are currently writing to.

The pipe we are currently reading from.

If true, more outgoing message parts are expected.

Peer ID are generated. It's a simple increment and wrap-over algorithm. This value is the next ID to use (if not used already).

If true, report EHOSTUNREACH to the caller instead of silently dropping the message targeting an unknown peer.

When enabled new router connections with same identity take over old ones

Create a new Router instance with the given parent-Ctx, thread-id, and socket-id.

the Ctx that will contain this Router the integer thread-id value the integer socket-id value

the Pipe to attach not used

This is an override of the abstract method that gets called to signal that the given pipe is to be removed from this socket.

the Pipe that is being removed

Indicate the given pipe as being ready for reading by this socket.

the Pipe that is now becoming available for reading

Indicate the given pipe as being ready for writing to by this socket. This gets called by the WriteActivated method.

the Pipe that is now becoming available for writing

Transmit the given message. The Send method calls this to do the actual sending.

the message to transmit true if the message was sent successfully The receiving host must be identifiable.

Receive a message. The Recv method calls this lower-level method to do the actual receiving.

the Msg to receive the message into true if the message was received successfully, false if there were no messages to receive

An instance of class Outpipe contains a Pipe and a boolean property Active.

If true, we are in process of sending the reply. If false we are in process of receiving a request.

If true, we are starting to receive a request. The beginning of the request is the backtrace stack.

Transmit the given message. The Send method calls this to do the actual sending.

the message to transmit true if the message was sent successfully XSend must only be called on Rep when in the state of sending a reply.

Receive a message. The Recv method calls this lower-level method to do the actual receiving.

the Msg to receive the message into true if the message was received successfully, false if there were no messages to receive XRecv must not be called on Rep while in the state of sending a reply.

A Req is a Dealer socket that serves as the Request in a Request/Response pattern.

If true, request was already sent and reply wasn't received yet or was received partially.

If true, we are starting to send/receive a message. The first part of the message must be empty message part (backtrace stack bottom).

Create a new Req (Request) socket with the given parent Ctx, thread and socket id.

the Ctx to contain this socket an integer thread-id for this socket to execute on the socket-id for this socket

Transmit the given message. The Send method calls this to do the actual sending.

the message to transmit true if the message was sent successfully Cannot XSend on a Req while awaiting reply.

Receive a message. The Recv method calls this lower-level method to do the actual receiving.

the Msg to receive the message into true if the message was received successfully, false if there were no messages to receive Req.XRecv expecting send, not receive. ReqSession must be in a valid state when PushMsg is called.

Fair queueing object for inbound pipes.

True if there is a message held in the pre-fetch buffer.

If true, the receiver got the message part with the peer's identity.

Holds the prefetched identity.

Holds the prefetched message.

Outbound pipes indexed by the peer IDs.

The pipe we are currently writing to.

If true, more outgoing message parts are expected.

Peer ID are generated. It's a simple increment and wrap-over algorithm. This value is the next ID to use (if not used already).

the Pipe to attach not used

This is an override of the abstract method that gets called to signal that the given pipe is to be removed from this socket.

the Pipe that is being removed

Indicate the given pipe as being ready for reading by this socket.

the Pipe that is now becoming available for reading

Indicate the given pipe as being ready for writing to by this socket. This gets called by the WriteActivated method.

the Pipe that is now becoming available for writing

Transmit the given message. The Send method calls this to do the actual sending.

the message to transmit true if the message was sent successfully In Stream.XSend

Receive a message. The Recv method calls this lower-level method to do the actual receiving.

the Msg to receive the message into true if the message was received successfully, false if there were no messages to receive

Fair queueing object for inbound pipes.

Object for distributing the subscriptions upstream.

The repository of subscriptions.

If true, 'message' contains a matching message to return on the next recv call.

If true, part of a multipart message was already received, but there are following parts still waiting.

the Pipe to attach not used

Indicate the given pipe as being ready for reading by this socket.

the Pipe that is now becoming available for reading

Indicate the given pipe as being ready for writing to by this socket. This gets called by the WriteActivated method.

the Pipe that is now becoming available for writing

This is an override of the abstract method that gets called to signal that the given pipe is to be removed from this socket.

the Pipe that is being removed

Transmit the given message. The Send method calls this to do the actual sending.

the message to transmit true if the message was sent successfully

Receive a message. The Recv method calls this lower-level method to do the actual receiving.

the Msg to receive the message into true if the message was received successfully, false if there were no messages to receive

An XSubSession is a subclass of SessionBase that provides nothing more.

Set the specified option on this socket - which must be either a SubScribe or an Unsubscribe.

which option to set the value to set the option to true if successful optionValue must be a String or a byte-array. XSend must return true.

XSend transmits a given message. The Send method calls this to do the actual sending. This override of that abstract method simply throws NotSupportedException because XSend is not supported on a Sub socket.

the message to transmit XSend not supported on Sub socket

Return false to indicate that XHasOut is not applicable on a Sub socket.

Make resize operation on array.

Type of containing data. Source array. New size of array. If grow/shrink operation should be applied to the end of array. Resized array.

List of outbound pipes.

Number of all the pipes to send the next message to.

Number of active pipes. All the active pipes are located at the beginning of the pipes array. These are the pipes the messages can be sent to at the moment.

Number of pipes eligible for sending messages to. This includes all the active pipes plus all the pipes that we can in theory send messages to (the HWM is not yet reached), but sending a message to them would result in partial message being delivered, ie. message with initial parts missing.

True if last we are in the middle of a multipart message.

Create a new, empty Distribution object.

Adds the pipe to the distributor object.

Mark the pipe as matching. Subsequent call to send_to_matching will send message also to this pipe.

Mark all pipes as non-matching.

This gets called by ProcessPipeTermAck or XTerminated to respond to the termination of the given pipe from the distributor.

the pipe that was terminated

Activates pipe that have previously reached high watermark.

Send the message to all the outbound pipes.

Send the message to the matching outbound pipes.

Put the message to all active pipes.

Write the message to the pipe. Make the pipe inactive if writing fails. In such a case false is returned.

This class manages a set of inbound pipes. On receive it performs fair queueing so that senders gone berserk won't cause denial of service for decent senders.

Inbound pipes.

Number of active pipes. All the active pipes are located at the beginning of the pipes array.

Index of the next bound pipe to read a message from.

If true, part of a multipart message was already received, but there are following parts still waiting in the current pipe.

This gets called by ProcessPipeTermAck or XTerminated to respond to the termination of the given pipe.

the pipe that was terminated

List of outbound pipes.

Number of active pipes. All the active pipes are located at the beginning of the pipes array.

Points to the last pipe that the most recent message was sent to.

True if last we are in the middle of a multipart message.

True if we are dropping current message.

This gets called by ProcessPipeTermAck or XTerminated to respond to the termination of the given pipe.

the pipe that was terminated

Multi-trie. Each node in the trie is a set of pointers to pipes.

Add key to the trie. Returns true if it's a new subscription rather than a duplicate.

Remove all subscriptions for a specific peer from the trie. If there are no subscriptions left on some topics, invoke the supplied callback function.

Remove specific subscription from the trie. Return true is it was actually removed rather than de-duplicated.

Signal all the matching pipes.

Add key to the trie. Returns true if this is a new item in the trie rather than a duplicate.

Remove key from the trie. Returns true if the item is actually removed from the trie.

Check whether particular key is in the trie.

Class Reaper is a ZObject and implements IPollEvents. The Reaper is dedicated toward handling socket shutdown asynchronously and cleanly. By passing this task off to the Reaper, the message-queueing subsystem can terminate immediately.

Reaper thread accesses incoming commands via this mailbox.

This is a Socket, used as the handle associated with the mailbox's file descriptor.

I/O multiplexing is performed using a poller object.

Number of sockets being reaped at the moment. These are the reason for having a reaper: to take over the task of terminating these sockets.

If true, we were already asked to terminate.

Create a new Reaper with the given thread-id. This will have a new Poller with the name "reaper-" + thread-id, and a Mailbox of that same name.

the Ctx for this to be in an integer id to give to the thread this will live on

Release any contained resources - by destroying the poller and closing the mailbox.

Start the contained Poller to begin polling.

Issue the Stop command to this Reaper object.

Handle input-ready events, by receiving and processing any commands that are waiting in the mailbox.

This method normally is for handling output-ready events, which don't apply here.

You must not call OutEvent on a Reaper.

This would be called when a timer expires - however in this event NotSupportedException would be thrown.

an integer used to identify the timer You must not call TimerEvent on a Reaper.

Respond to the Stop command by signaling the polling-loop to terminate, and if there're no sockets left to reap - stop the poller.

Add the given socket to the list to be reaped (terminated).

the socket to add to the list for termination

Respond to having one of the sockets that are marked for reaping, - finished being reaped, and if there are none left - send the Done command and stop the poller.

Get the Mailbox that this Reaper uses for communication with the rest of the message-queueing subsystem.

The class ByteArraySegment provides for containing a simple byte-array, an Offset property, and a variety of operations that may be performed upon it.

Create a new ByteArraySegment containing the given byte-array buffer.

the byte-array for the new ByteArraySegment to contain

Create a new ByteArraySegment containing the given byte-array buffer with the given offset.

the byte-array for the new ByteArraySegment to contain the value for the Offset property

Create a new ByteArraySegment that is a shallow-copy of the given ByteArraySegment (with a reference to the same buffer).

the source-ByteArraySegment to make a copy of

Create a new ByteArraySegment that is a shallow-copy of the given ByteArraySegment (with a reference to the same buffer) but with a different offset.

the source-ByteArraySegment to make a copy of a value for the Offset property that is distinct from that of the source ByteArraySegment

Add the given value to the offset.

the delta value to add to the offset.

Write the given 64-bit value into the buffer, at the position marked by the offset plus the given index i.

an Endianness to specify in which order to write the bytes the 64-bit value to write into the byte-array buffer the index position beyond the offset to start writing the bytes

Write the given 16-bit value into the buffer, at the position marked by the offset plus the given index i.

an Endianness to specify in which order to write the bytes the 16-bit value to write into the byte-array buffer the index position beyond the offset to start writing the bytes

Write the given 32-bit value into the buffer, at the position marked by the offset plus the given index i.

an Endianness to specify in which order to write the bytes the 32-bit value to write into the byte-array buffer the index position beyond the offset to start writing the bytes

Encode the given String into a byte-array using the ASCII encoding and write that into the buffer.

the String to write to the buffer the number of encoded bytes to copy into the buffer an index-offset, in addition to the Offset property, that marks where in the buffer to start writing bytes to

Encode the given String into a byte-array using the ASCII encoding and write that into the buffer.

the String to write to the buffer an index-offset, in addition to the Offset property, that marks where in the buffer to start writing bytes to

Return a 64-bit numeric value that is read from the buffer, starting at the position marked by the offset plus the given index i, based upon the given byte-ordering.

an Endianness to specify which byte-ordering to use to interpret the source bytes the index position beyond the offset to start reading the bytes a long that is read from the bytes of the buffer

Return a 64-bit unsigned numeric value (ulong) that is read from the buffer, starting at the position marked by the offset plus the given index i, based upon the given byte-ordering.

an Endianness to specify which byte-ordering to use to interpret the source bytes the index position beyond the offset to start reading the bytes an unsigend long that is read from the bytes of the buffer

Return a 32-bit integer that is read from the buffer, starting at the position marked by the offset plus the given index i, based upon the given byte-ordering.

an Endianness to specify which byte-ordering to use to interpret the source bytes the index position beyond the offset to start reading the bytes an integer that is read from the bytes of the buffer

Return a 16-bit unsigned integer (ushort) value that is read from the buffer, starting at the position marked by the offset plus the given index i, based upon the given byte-ordering.

an Endianness to specify which byte-ordering to use to interpret the source bytes the index position beyond the offset to start reading the bytes a ushort that is read from the bytes of the buffer

Return a String that is read from the byte-array buffer, decoded using the ASCII encoding, starting at the position marked by the offset plus the given index i.

the length of the part of the buffer to read the index position beyond the offset to start reading the bytes a String decoded from the bytes of the buffer

Write the bytes of this ByteArraySegment to the specified destination-ByteArraySegment.

the destination-ByteArraySegment the number of bytes to copy

Write the bytes of this ByteArraySegment to the specified destination-ByteArraySegment.

an offset within this source buffer to start copying from the destination-ByteArraySegment an offset within the destination buffer to start copying to the number of bytes to copy

Return a shallow-copy of this ByteArraySegment.

a new ByteArraySegment that is a shallow-copy of this one

Set the offset to zero.

Return a new ByteArraySegment that has the data of this one, but with the given offset.

the source-ByteArraySegment the offset-value to give the new ByteArraySegment

Return a new ByteArraySegment that contains the given byte-array buffer.

the source byte-array buffer a new ByteArraySegment that contains the given buffer

Return the byte-array buffer of this ByteArraySegment.

the source-ByteArraySegment the byte-array that is the buffer of this ByteArraySegment

Return true if the given Object is a ByteArraySegment and has the same buffer and offset.

an Object to compare for equality to this one true only if the otherObject has the same buffer and offset The given Object is considered to be Equal if it also is a ByteArraySegment, and has the same Offset property value and it's buffer points to the SAME byte-array as the otherObject does.

Get the number of bytes within the buffer that is past the Offset (ie, buffer-length minus offset).

Get the offset into the buffer.

Get or set the byte of the buffer at the i-th index position (zero-based).

the index of the byte to access

Helper base class for decoders that know the amount of data to read in advance at any moment. This class is the state machine that parses the incoming buffer. Derived classes should implement individual state machine actions.

Knowing the amount in advance is a property of the protocol used. 0MQ framing protocol is based size-prefixed paradigm, which qualifies it to be parsed by this class. On the other hand, XML-based transports (like XMPP or SOAP) don't allow for knowing the size of data to read in advance and should use different decoding algorithms.

Where to store the read data.

How much data to read before taking next step.

The buffer for data to decode.

Returns true if the decoder has been fed all required data but cannot proceed with the next decoding step. False is returned if the decoder has encountered an error.

Returns a buffer to be filled with binary data.

Processes the data in the buffer previously allocated using get_buffer function. size argument specifies the number of bytes actually filled into the buffer. Function returns number of bytes actually processed.

Interface IEncoder mandates SetMsgSource and GetData methods.

Set message producer.

Get a ByteArraySegment of binary data. The data are filled to a supplied buffer. If no buffer is supplied (data is null) encoder will provide buffer of its own.

Where to get the data to write from.

If true, first byte of the message is being written.

How much data to write before the next step should be executed.

The buffer for encoded data.

The size of the encoded-data buffer

This flag indicates whether there has been an encoder error.

Create a new EncoderBase with a buffer of the given size.

how big of an internal buffer to allocate (in bytes) the to set this EncoderBase to

This returns a batch of binary data. The data are filled to a supplied buffer. If no buffer is supplied (data_ points to NULL) decoder object will provide buffer of its own.

Set a flag that indicates that there has been an encoding-error.

Return true if there has been an encoding error.

the state of the error-flag

Get the Endianness (Big or Little) that this EncoderBase uses.

Abstract interface to be implemented by various engines.

Plug the engine to the session.

Terminate and deallocate the engine. Note that 'detached' events are not fired on termination.

This method is called by the session to signal that more messages can be written to the pipe.

This method is called by the session to signal that there are messages to send available.

IpcConnecter is a subclass of TcpConnector, which provides absolutely nothing beyond what TcpConnector does.

If 'delay' is true connector first waits for a while, then starts connection process.

ID of the timer used to delay the reconnection. Value is 1.

Address to connect to. Owned by session_base_t.

The underlying AsyncSocket.

If true file descriptor is registered with the poller and 'handle' contains valid value.

If true, connector is waiting a while before trying to connect.

True if a timer has been started.

Reference to the session we belong to.

Current reconnect-interval. This gets updated for back-off strategy.

String representation of endpoint to connect to

Socket

Create a new TcpConnector object.

the I/O-thread for this TcpConnector to live on. the session that will contain this Options that define this new TcpC the Address for this Tcp to connect to this boolean flag dictates whether to wait before trying to connect

This does nothing.

Begin connecting. If a delayed-start was specified - then the reconnect-timer is set, otherwise this starts immediately.

Process a termination request. This cancels the reconnect-timer, closes the AsyncSocket, and marks the socket-handle as invalid.

a time (in milliseconds) for this to linger before actually going away. -1 means infinite.

This method would be called when a message receive operation has been completed, although here it only throws a NotImplementedException.

a SocketError value that indicates whether Success or an error occurred the number of bytes that were transferred InCompleted must not be called on a TcpConnector.

Internal function to start the actual connection establishment.

This method is called when a message Send operation has been completed.

a SocketError value that indicates whether Success or an error occurred the number of bytes that were transferred A non-recoverable socket error occurred. If the socketError is not Success then it must be a valid recoverable error.

This is called when the timer expires - to start trying to connect.

The timer-id. This is not used.

Internal function to add a reconnect timer

Internal function to return a reconnect back-off delay. Will modify the current_reconnect_ivl used for next call Returns the currently used interval

Close the connecting socket.

An IpcListener is a TcpListener that also has an Address property and a SetAddress method.

Address to listen on.

Underlying socket.

socket being accepted

Socket the listener belongs to.

String representation of endpoint to bind to

The port that was bound on

Create a new TcpListener on the given IOThread and socket.

the IOThread for this to live within a SocketBase to listen on socket-related Options

Release any contained resources (here - does nothing).

Process a termination request.

a time (in milliseconds) for this to linger before actually going away. -1 means infinite.

Set address to listen on.

a string denoting the address to set this to

This is called when socket input has been completed.

This indicates the status of the input operation - whether Success or some error. the number of bytes that were transferred A non-recoverable socket-error occurred.

Close the listening socket.

This method would be called when a message Send operation has been completed - except in this case it simply throws a NotImplementedException.

a SocketError value that indicates whether Success or an error occurred the number of bytes that were transferred OutCompleted is not implemented on TcpListener.

This would be called when a timer expires, although here it only throws a NotSupportedException.

an integer used to identify the timer (not used here) TimerEvent is not supported on TcpListener.

Get the bound address for use with wildcards

Get the port-number to listen on.

Create a new IpcListener with the given IOThread, socket, and Options.

the SocketBase to listen to an Options value that dictates the settings for this IpcListener

Set address to listen on.

a string denoting the address to listen to

Get the bound address for use with wildcards

Unable to parse the address's port number, or the IP address could not be parsed. Unable to parse the address's port number, or the IP address could not be parsed. Unable to parse the address's port number, or the IP address could not be parsed. Error establishing underlying socket.

Process a termination request.

a time (in milliseconds) for this to linger before actually going away. -1 means infinite.

This method is called when a message receive operation has been completed.

a SocketError value that indicates whether Success or an error occurred the number of bytes that were transferred

This method would be called when a message Send operation has been completed, although here it only throws a NotSupportedException.

a SocketError value that indicates whether Success or an error occurred the number of bytes that were transferred This operation is not supported on the PgmListener class.

This would be called when the a expires, although here it only throws a NotSupportedException.

an integer used to identify the timer (not used here) This operation is not supported on the PgmListener class.

ID of the timer used to delay the reconnection. Value is 1.

This would be called when a timer expires, although here it only throws a NotSupportedException.

an integer used to identify the timer (not used here) This method must not be called on instances of PgmSender.

This method is called when a message Send operation has been completed.

a SocketError value that indicates whether Success or an error occurred the number of bytes that were transferred A non-recoverable socket error occurred.

Internal function to return a reconnect back-off delay. Will modify the current_reconnect_ivl used for next call Returns the currently used interval

This method would be called when a message receive operation has been completed, although here it only throws a NotSupportedException.

a SocketError value that indicates whether Success or an error occurred the number of bytes that were transferred This method must not be called on instances of PgmSender.

This method is be called when a message receive operation has been completed.

a SocketError value that indicates whether Success or an error occurred the number of bytes that were transferred

This method would be called when a message Send operation has been completed, except in this case this method does nothing.

a SocketError value that indicates whether Success or an error occurred the number of bytes that were transferred

This would be called when a timer expires, although here it does nothing.

an integer used to identify the timer (not used here)

This enum-type is Idle, Receiving, Stuck, or Error.

This enum-type denotes the type of Pragmatic General Multicast (PGM) socket. Publisher, Receiver, or Listener.

A PgmSocket utilizes the Pragmatic General Multicast (PGM) multicast protocol, which is also referred to as "reliable multicast". This is only supported on Windows when Microsoft Message Queueing (MSMQ) is installed. See RFC 3208.

Set/Query rate (Kb/Sec) + window size (Kb and/or MSec) -- described by RM_SEND_WINDOW below

set IP multicast outgoing interface

add IP multicast incoming interface

Set the Time-To-Live (TTL) of the MCast packets -- (ULONG)

Perform initialization of this PgmSocket, including creating the socket handle.

Override the ToString method to produce a more descriptive, useful description.

a useful description of this object's state

This method is be called when a message receive operation has been completed.

a SocketError value that indicates whether Success or an error occurred the number of bytes that were transferred

This method is called when a message Send operation has been completed.

a SocketError value that indicates whether Success or an error occurred the number of bytes that were transferred the SocketError that resulted from the write - which could be Success (no error at all) this indicates the number of bytes that were transferred in the write the number of bytes transferred if successful, -1 otherwise If the socketError is not Success then it must be a valid recoverable error or the number of bytes transferred must be zero. If socketError is SocketError.Success and bytesTransferred is > 0, then this returns bytesTransferred. If bytes is zero, or the socketError is one of NetworkDown, NetworkReset, HostUn, Connection Aborted, TimedOut, or ConnectionReset, - then -1 is returned. Otherwise, a NetMQException is thrown. the SocketError that resulted from the read - which could be Success (no error at all) this indicates the number of bytes that were transferred in the read the number of bytes transferred if successful, -1 otherwise If the socketError is not Success then it must be a valid recoverable error or the number of bytes transferred must be zero. If socketError is SocketError.Success and bytesTransferred is > 0, then this returns bytesTransferred. If bytes is zero, or the socketError is one of NetworkDown, NetworkReset, HostUn, Connection Aborted, TimedOut, or ConnectionReset, - then -1 is returned. Otherwise, a NetMQException is thrown.

This would be called when a timer expires, although here it only throws NotSupportedException.

an integer used to identify the timer (not used here) TimerEvent is not supported on StreamEngine.

This enum-type denotes the operational state of this StreamEngine - whether Closed, doing Handshaking, Active, or Stalled.

A TcpAddress implements IZAddress, and contains an IPEndPoint (the Address property) and a Protocol property.

Override ToString to provide a detailed description of this object's state in the form: Protocol://[AddressFamily]:Port

a string in the form Protocol://[AddressFamily]:Port

Given a string that should identify an endpoint-address, resolve it to an actual IP address and set the Address property to a valid corresponding value.

the endpoint-address to resolve whether the address must be only-IPv4 The name must contain the colon delimiter. The specified port must be a valid nonzero integer. Must be able to find the IP-address.

Get the Address implementation - which here is an IPEndPoint, which contains Address, AddressFamily, and Port properties.

Get the textual-representation of the communication protocol implied by this TcpAddress, which here is simply "tcp".

The maximum message-size. If this is -1 then there is no maximum.

Create a new V1Decoder with the given buffer-size, maximum-message-size and Endian-ness.

the buffer-size to give the contained buffer the maximum message size. -1 indicates no limit. the Endianness to specify for it - either Big or Little

Set the receiver of decoded messages.

Encoder for 0MQ framing protocol. Converts messages into data stream.

V2Protocol is a class that contains two integer constants: MoreFlag and LargeFlag.

This is a constant-integer with the value 1.

This is a constant-integer with the value 2.

This class simply provides a counter-value, which may be set, increased, and decremented. Increase and Decrement are both thread-safe operations.

Create a new AtomicCounter object with an initial counter-value of zero.

Assign the given amount to the counter-value.

the integer value to set the counter to

Add the given amount to the counter-value, in an atomic thread-safe manner.

the integer amount to add to the counter-value

Subtract the given amount from the counter-value, in an atomic thread-safe manner.

the integer amount to subtract from to the counter-value (default value is 1) the new value of the counter

Class ByteArrayEqualityComparer is an IEqualityComparer for byte-arrays, and provides an Equals methods to compare two byte-arrays for equality in value and GetHashCode.

Return true only if the two byte-arrays are equal in length and contain the same values.

one of the two byte-arrays to compare the other byte-array to compare against

Return a numeric hashcode of the given byte-array.

the given byte-array to compute the hashcode of an integer that contains a hashcode computed over the byte-array

The Clock class provides properties for getting timer-counts in either milliseconds or microseconds, and the CPU's timestamp-counter if available.

TSC timestamp of when last time measurement was made.

Physical time corresponding to the TSC above (in milliseconds).

This flag indicates whether the rdtsc instruction is supported on this platform.

Return the High-Precision timestamp, as a 64-bit integer that denotes microseconds.

Return the Low-Precision timestamp, as a 64-bit integer denoting milliseconds. In tight loops generating it can be 10 to 100 times faster than the High-Precision timestamp.

Return the CPU's timestamp counter, or 0 if it's not available.

This serves as the parent-class for Poller and Proactor. It provides for managing a list of timers (ITimerEvents) - adding, cancelling, and executing them, and a Load property.

Load of the poller. Currently the number of file descriptors registered.

This is a list of key/value pairs, with the keys being timeout numbers and the corresponding values being a list of TimerInfo objects. It is sorted by the keys - which are timeout values. Thus, by walking down the list, you encounter the soonest timeouts first.

Create a new PollerBase object - which simply creates an empty m_timers collection.

Add the given amount to the load. This is called by individual poller implementations to manage the load.

This is thread-safe.

Add a to the internal list, created from the given sink and id - to expire in the given number of milliseconds. Afterward the expiration method TimerEvent on the sink object will be called with argument set to id.

the timeout-period in milliseconds of the new timer the IProactorEvents to add for the sink of the new timer the Id to assign to the new TimerInfo

Cancel the timer that was created with the given sink object with the given Id.

the ITimerEvent that the timer was created with the Id of the timer to cancel The complexity of this operation is O(n). We assume it is rarely used.

Execute any timers that are due. Return the number of milliseconds to wait to match the next timer or 0 meaning "no timers".

the time to wait for the next timer, in milliseconds, or zero if there are no more timers

Get the load of this poller. Note that this function can be invoked from a different thread!

Instances of this class contain a ITimerEvent sink and an integer Id.

Create a new TimerInfo object from the given sink and id.

an ITimerEvent that acts as a sink for when the timer expires an integer id that identifies this timer

Get the ITimerEvent that serves as the event-sink.

Get the integer Id of this TimerInfo.

This is the list of registered descriptors (PollSets).

List of sockets to add at the start of the next loop

If true, there's at least one retired event source.

This flag is used to tell the polling-loop thread to shut down, wherein it will stop at the end of it's current loop iteration.

This indicates whether the polling-thread is not presently running. Default is true.

This is the background-thread that performs the polling-loop.

This is the name associated with this Poller.

The set of Sockets to check for read-readiness.

The set of Sockets to check for any errors.

Create a new Poller object with the given name.

a name to assign to this Poller

Unless the polling-loop is already stopped, tell it to stop at the end of the current polling iteration, and wait for that thread to finish.

Add a new PollSet containing the given Socket and IPollEvents at the next iteration through the loop, and also add the Socket to the list of those to check for errors.

the Socket to add the IPollEvents to include in the new PollSet to add

Remove the given Socket from this Poller.

the System.Net.Sockets.Socket to remove

Add the given Socket to the list to be checked for read-readiness at each poll-iteration.

the Socket to add

Begin running the polling-loop, on a background thread.

The name of that background-thread is the same as the name of this Poller object.

Signal that we want to stop the polling-loop. This method returns immediately - it does not wait for the polling thread to stop.

This method is the polling-loop that is invoked on a background thread when Start is called. As long as Stop hasn't been called: execute the timers, and invoke the handler-methods on each of the saved PollSets.

A PollSet contains a single Socket and an IPollEvents Handler that provides methods that signal when that socket is ready for reading or writing.

Create a new PollSet object to hold the given Socket and IPollEvents handler.

the Socket to contain the IPollEvents to signal when ready for reading or writing

Get the Socket that this PollSet contains.

Get the IPollEvents object that has methods to signal when ready for reading or writing.

Get or set whether this PollSet is cancelled.

The completionStatuses item must have a valid OperationType.

A SelectItem is a pairing of a (Socket or SocketBase) and a PollEvents value.

A Selector holds three lists of Sockets - for read, write, and error, and provides a Select method.

(must not be null) a time-out period, in milliseconds The internal select operation failed. is null. The socket has been stopped.

Close the read and write sockets.

This class exists only to provide a wrapper for the Socket.Select method, such that the call may be handled slightly differently on .NET 3.5 as opposed to later versions.

Determine the status of one or more sockets. After returning, the lists will be filled with only those sockets that satisfy the conditions.

a list of Sockets to check for readability a list of Sockets to check for writability a list of Sockets to check for errors a timeout value, in microseconds. A value of -1 indicates an infinite timeout. If you are in a listening state, readability means that a call to Accept will succeed without blocking. If you have already accepted the connection, readability means that data is available for reading. In these cases, all receive operations will succeed without blocking. Readability can also indicate whether the remote Socket has shut down the connection - in which case a call to Receive will return immediately, with zero bytes returned. Select returns when at least one of the sockets of interest (ie any of the sockets in the checkRead, checkWrite, or checkError lists) meets its specified criteria, or the microSeconds parameter is exceeded - whichever comes first. Setting microSeconds to -1 specifies an infinite timeout. If you make a non-blocking call to Connect, writability means that you have connected successfully. If you already have a connection established, writability means that all send operations will succeed without blocking. If you have made a non-blocking call to Connect, the checkError parameter identifies sockets that have not connected successfully. See this reference for further details of the operation of the Socket.Select method: https://msdn.microsoft.com/en-us/library/system.net.sockets.socket.select(v=vs.110).aspx This may possibly throw an ArgumentNullException, if all three lists are null or empty, and a SocketException if an error occurred when attempting to access a socket. Use the Poll method if you only want to determine the status of a single Socket. This method cannot detect certain kinds of connection problems, such as a broken network cable, or that the remote host was shut down ungracefully. You must attempt to send or receive data to detect these kinds of errors. none of the three lists of sockets may be null. an error occurred when attempting to access the socket.

Implementations provide a via the property.

Gets a instance.

StringLib is a static class whose purpose is to provide miscellaneous string-related utility methods and extension properties.

Return a string that gives detailed information of the state of the given List of Sockets, for debugging purposes.

the List of Sockets to describe a string detailing the list contents, including the state of each Socket This is intended just for debugging purposes, as when adding detailed information to the Message of an exception when an error occurs. In DEBUG mode more detail is provided.

Return a detailed textual description of the state of this Socket (if DEBUG is defined).

the System.Net.Sockets.Socket to describe a string containing a detailed listing of the properties of the Socket This is intended just for debugging purposes, as when adding detailed information to the Message of an exception when an error occurs. In DEBUG mode more detail is provided.

A FIFO queue.

The class supports: Push-front via . Pop-back via . Pop-front via . As such it is only one operation short of being a double-ended queue (dequeue or deque). The internal implementation consists of a doubly-linked list of fixed-size arrays. the size to give the new YQueue should be no less than 2

Retrieves the element at the front of the queue.

The element taken from queue.

Adds an element to the back end of the queue.

The value to be pushed.

Removes element from the back end of the queue, rolling back the last call to .

The caller must guarantee that the queue isn't empty when calling this method. It cannot be done automatically as the read side of the queue can be managed by different, completely unsynchronized threads. The last item passed to .

Gets the index of the front element of the queue.

The index of the front element of the queue. If the queue is empty, it should be equal to .

Gets the front element of the queue. If the queue is empty, behaviour is undefined.

The front element of the queue.

Gets the index of the back element of the queue.

The index of the back element of the queue. If the queue is empty, it should be equal to .

Individual memory chunk to hold N elements.

Contains global index positions of elements in the chunk.

Optional link to the previous .

Optional link to the next .

Allocation-efficient queue to store pipe items. Front of the queue points to the first prefetched item, back of the pipe points to last un-flushed item. Front is used only by reader thread, while back is used only by writer thread.

Points to the first un-flushed item. This variable is used exclusively by writer thread.

Points to the first un-prefetched item. This variable is used exclusively by reader thread.

Points to the first item to be flushed in the future.

The single point of contention between writer and reader thread. Points past the last flushed item. If it is NULL, reader is asleep. This pointer should be always accessed using atomic operations.

Write an item to the pipe. Don't flush it yet. If incomplete is set to true the item is assumed to be continued by items subsequently written to the pipe. Incomplete items are never flushed down the stream.

Pop an incomplete item from the pipe.

the element revoked if such item exists, null otherwise.

Flush all the completed items into the pipe.

Returns false if the reader thread is sleeping. In that case, caller is obliged to wake the reader up before using the pipe again.

Check whether item is available for reading.

Attempts to read an item from the pipe.

true if the read succeeded, otherwise false.

Applies the function fn to the first element in the pipe and returns the value returned by the fn. The pipe mustn't be empty or the function crashes.

This enum-type serves to identity a particular socket-option.

The I/O-thread affinity. 0 means no affinity, meaning that work shall be distributed fairly among all I/O threads. For non-zero values, the lowest bit corresponds to thread 1, second lowest bit to thread 2, and so on.

The I/O-thread Affinity is a 64-bit value used to specify which threads from the I/O thread-pool associated with the socket's context shall handle newly-created connections. 0 means no affinity, meaning that work shall be distributed fairly among all I/O threads. For non-zero values, the lowest bit corresponds to thread 1, second lowest bit to thread 2, and so on.

The unique identity of the socket, from a message-queueing router's perspective.

This is at most 255 bytes long.

Setting this option subscribes a socket to messages that have the given topic. This is valid only for Subscriber and XSubscriber sockets.

You subscribe a socket to a given topic when you want that socket to receive messages of that topic. A topic is simply a specific prefix (in the form of a byte-array or the equivalent text). This is valid only for Subscriber and XSubscriber sockets.

Set this option to un-subscribe a socket from a given topic. Only for Subscriber and XSubscriber sockets.

You un-subscribe a socket from the given topic when you no longer want that socket to receive messages of that topic. A topic is simply a specific prefix (in the form of a byte-array or the equivalent text). This is valid only for Subscriber and XSubscriber sockets.

The maximum send or receive data rate for multicast transports on the specified socket.

The recovery-interval, in milliseconds, for multicast transports using the specified socket. Default is 10,000 ms (10 seconds).

This option determines the maximum time that a receiver can be absent from a multicast group before unrecoverable data loss will occur. Default is 10,000 ms (10 seconds).

The size of the transmit buffer for the specified socket.

The size of the receive buffer for the specified socket.

This indicates more messages are to be received.

The file descriptor associated with the specified socket.

The event state for the specified socket. This is a combination of: PollIn - at least one message may be received without blocking PollOut - at least one messsage may be sent without blocking

This option specifies the linger period for the specified socket, which determines how long pending messages which have yet to be sent to a peer shall linger in memory after a socket is closed.

The initial reconnection interval for the specified socket. -1 means no reconnection.

This is the period to wait between attempts to reconnect disconnected peers when using connection-oriented transports. A value of -1 means no reconnection.

This is the maximum length of the queue of outstanding peer connections for the specified socket. This only applies to connection-oriented transports. Default is 100.

The maximum reconnection interval for the specified socket. The default value of zero means no exponential backoff is performed.

This option value denotes the maximum reconnection interval for a socket. It is used when a connection drops and NetMQ attempts to reconnect. On each attempt to reconnect, the previous interval is doubled until this maximum period is reached. The default value of zero means no exponential backoff is performed.

The upper limit to to the size for inbound messages. -1 (the default value) means no limit.

If a peer sends a message larger than this it is disconnected.

The high-water mark for message transmission, which is the number of messages that are allowed to queue up before mitigative action is taken. The default value is 1000.

The high-water mark for message reception, which is the number of messages that are allowed to queue up before mitigative action is taken. The default value is 1000.

The time-to-live (maximum number of hops) that outbound multicast packets are allowed to propagate. The default value of 1 means that the multicast packets don't leave the local network.

Specifies the amount of time after which a synchronous receive call will time out.

Specifies the amount of time after which a synchronous send call will time out. A value of 0 means Send will return immediately, with a EAGAIN error if the message cannot be sent. -1 means to block until the message is sent.

This indicates the underlying native socket type.

An IPv4 socket will only use IPv4, while an IPv6 socket lets applications connect to and accept connections from both IPv4 and IPv6 hosts.

The last endpoint bound for TCP and IPC transports. The returned value will be a string in the form of a ZMQ DSN.

If the TCP host is ANY, indicated by a *, then the returned address will be 0.0.0.0 (for IPv4).

Whether to use TCP keep-alive on this socket. 0 = no, 1 = yes, -1 (the default value) means to skip any overrides and leave it to the OS default.

The keep-alive time - the duration between two keepalive transmissions in idle condition.

The TCP keepalive period is required by socket implementers to be configurable and by default is set to no less than 2 hours. In 0MQ, -1 (the default value) means to just leave it to the OS default.

The TCP keep-alive interval - the duration between two keepalive transmission if no response was received to a previous keepalive probe.

By default a keepalive packet is sent every 2 hours or 7,200,000 milliseconds if no other data have been carried over the TCP connection. If there is no response to a keepalive, it is repeated once every KeepAliveInterval seconds. The default is one second.

The list of accept-filters, which denote the addresses that a socket may accept. Setting this to null clears the filter.

This applies to IPv4 addresses only.

This applies only to XPub sockets. If true, send all subscription messages upstream, not just unique ones. The default is false.

This is an XPublisher-socket welcome-message.

This applies only to XPub sockets. If true, enable broadcast option on XPublishers

The low-water mark for message transmission. This is the number of messages that should be processed before transmission is unblocked (in case it was blocked by reaching high-watermark). The default value is calculated using relevant high-watermark (HWM): HWM > 2048 ? HWM - 1024 : (HWM + 1) / 2

The low-water mark for message reception. This is the number of messages that should be processed before reception is unblocked (in case it was blocked by reaching high-watermark). The default value is calculated using relevant high-watermark (HWM): HWM > 2048 ? HWM - 1024 : (HWM + 1) / 2

When enabled new router connections with same identity take over old ones

Specifies the byte-order: big-endian, vs little-endian.

This enum-type specifies either big-endian (Big) or little-endian (Little), which indicate whether the most-significant bits are placed first or last in memory.

Most-significant bits are placed first in memory.

Most-significant bits are placed last in memory.

This enum-type represents the various numeric socket-related error codes.

The provided endpoint is not connected.

The requested address is already in use.

Non-blocking mode was requested and the message cannot be sent at the moment.

Permission denied

The endpoint supplied is invalid.

The connection is still in progress.

The requested transport protocol is not supported.

The provided context is invalid.

The requested address was not available. For Bind operations, that can mean the address was not local.

The network appears to be down.

There is not enough buffer space for the requested operation.

The socket is not connected.

The connection was refused.

The host is not reachable.

This is the value chosen for beginning the range of 0MQ error codes.

The message is too long.

The address family is not supported by this protocol.

The network is apparently not reachable.

The connection-attempt has apparently been aborted.

The connection has apparently been reset.

The operation timed-out.

The connection has apparently been reset.

The operation cannot be performed on this socket at the moment due to the socket not being in the appropriate state.

The context associated with the specified socket has already been terminated.

No I/O thread is available to accomplish this task.

Too many sockets for this process.

The provided endpoint is not connected.

The operation was interrupted by a signal.

Permission denied

The provided context is invalid.

The endpoint supplied is invalid.

Non-blocking mode was requested and the message cannot be sent at the moment.

The connection is still in progress.

The requested transport protocol is not supported.

That operation is not supported by this socket type.

The requested address is already in use.

The requested address was not available. For Bind operations, that can mean the address was not local.

The network appears to be down.

There is not enough buffer space for the requested operation.

Unused

The socket is not connected.

The connection was refused.

The host is not reachable.

This is the value chosen for beginning the range of 0MQ error codes.

The provided socket was invalid.

The message is too long.

The address family is not supported by this protocol.

The network is apparently not reachable.

The connection-attempt has apparently been aborted.

The connection has apparently been reset.

The operation timed-out.

The network was reset.

The operation cannot be performed on this socket at the moment due to the socket not being in the appropriate state.

The requested transport protocol is not compatible with the socket type.

The context associated with the specified socket has already been terminated.

No I/O thread is available to accomplish this task.

Unused

Too many sockets for this process.

ErrorPollingException is an Exception that had been used within the message-queueing system to signal polling-related errors. Use one of the NetMQException-derived exception classes instead.

Create a new ErrorPollingException containing the given message and a reference to the given socket.

the textual description of what gave rise to this exception, to be exposed as the Message property a reference to the socket, to be exposed via the Socket property

Get the NetMQSocket that this exception holds a reference to.

Facilitates a pattern whereby an event may be decorated with logic that transforms its arguments.

Use of this class requires providing actions that register and unregister a handler of the source event that calls with updated arguments in response. Argument type of the decorated event.

Initialises a new instance.

an Action to perform when the first handler is registered for the event an Action to perform when the last handler is unregistered from the event

Raise, or "Fire", the Event.

the sender that the event-handler that gets notified of this event will receive the subclass of EventArgs that the event-handler will receive

class InterfaceItem provides the properties Address and BroadcastAddress (both are an IPAddress). This serves to convey information for each of the network interfaces present on a host.

Create a new InterfaceItem from the given address and broadcast-address.

an IPAddress that will comprise the 'Address' of the new InterfaceItem an IPAddress that will comprise the 'BroadcastAddress' of the new InterfaceItem

Get the 'address' of this network interface, as an IPAddress.

Get the 'broadcast-address' of this network interface, as an IPAddress.

This is a list of InterfaceItems, each of which has an Address and BroadcastAddress, which is derived from all of the Network Interfaces present on this host at the time an instance of this class is created.

Create a new InterfaceCollection that contains a list of InterfaceItems derived from all of the Network Interfaces present on this host.

Return an IEnumerator over the InterfaceItems that this InterfaceCollection contains, which are all of the network interfaces that were not running, nor loopback nor PPP interfaces.

an IEnumerator over the InterfaceItems that this contains

Interface IOutgoingSocket mandates a Send( Msg, SendReceiveOptions ) method.

Send the given Msg out upon this socket. The message content is in the form of a byte-array that Msg contains.

the Msg struct that contains the data and the options for this transmission a SendReceiveOptions value that can specify the DontWait or SendMore bits (or None) The send operation timed out.

Send a message if one is available within .

An object with message's data to send. The maximum length of time to try and send a message. If , no wait occurs. Indicate if another frame is expected after this frame true if a message was sent, otherwise false.

Defines a socket from which message data may be read.

Read message data into the given object.

If a message is available, its content will be transferred to and the call will return immediately. If no message is available, the behaviour of this method depends upon : — causes the method to immediately throw . — blocks until the next message arrives, and cannot be interrupted. This a convenient and safe when you know a message is available, such as for code within a callback. objects having non-negative values will timeout if a message is not received within the specified number of milliseconds. An object to receive the message's data into. A set of flags that control receipt. Only and have any effect. makes no sense here and is ignored. No message was available within the allowed timeout period. Try again.

Receive a message if one is available within .

An object to receive the message's data into. The maximum length of time to wait for a message. If , no wait occurs. true if a message was received, otherwise false.

This interface provides an abstraction over the legacy Poller and newer classes for use in .

Monitors a for events, raising them via events.

To run a monitor instance, either: Call (blocking) and , or Call and .

Initialises a monitor on for a specified .

This constructor matches the signature used by clrzmq. The socket to monitor. a string denoting the endpoint which will be the monitoring address A flag indicating whether ownership of is transferred to the monitor. If true, disposing the monitor will also dispose .

Start monitor the socket, the method doesn't start a new thread and will block until the monitor poll is stopped

The Monitor must not have already started nor attached to a poller.

Start a background task for the monitoring operation.

Stop monitoring. Blocks until monitoring completed.

If this monitor is attached to a poller you must detach it first and not use the stop method.

Release and dispose of any contained resources.

true if releasing managed resources

The monitoring address.

Get whether this monitor is currently running.

Start the monitor running via either or . Stop the monitor via either or .

Gets and sets the timeout interval for poll iterations when using and .

The higher the number the longer it may take the to stop the monitor. This value has no effect when the monitor is run via .

Raised whenever any monitored event fires.

Occurs when a connection is made to a socket.

Occurs when a synchronous connection attempt failed, and its completion is being polled for.

Occurs when an asynchronous connect / reconnection attempt is being handled by a reconnect timer.

Occurs when a socket is bound to an address and is ready to accept connections.

Occurs when a socket could not bind to an address.

Occurs when a connection from a remote peer has been established with a socket's listen address.

Occurs when a connection attempt to a socket's bound address fails.

Occurs when a connection was closed.

Occurs when a connection couldn't be closed.

Occurs when the stream engine (TCP and IPC specific) detects a corrupted / broken session.

Base class for all event arguments raised by .

Create a new NetMQMonitorEventArgs that contains the given monitor and address.

The that raised this event. The address of the event. The type of socket event that occurred.

Gets the that raised this event.

Gets the address of the event.

Gets the type of socket event that occurred.

A subclass of that also holds a socket.

Create a new NetMQMonitorSocketEventArgs that contains the given monitor, address, and socket.

The that raised this event. The address of the event. The type of socket event that occurred. The socket upon which this event occurred.

Gets the socket upon which this event occurred.

A subclass of that also holds an error code.

Create a new NetMQMonitorErrorEventArgs that contains the given monitor, address, and error-code.

The that raised this event. The address of the event. The type of socket event that occurred. The error code associated with this event.

Gets the error code associated with this event.

A subclass of that also holds an interval.

Create a new NetMQMonitorIntervalEventArgs containing the given NetMQMonitor, address, and interval.

the NetMQMonitor The a string denoting the address The interval, in milliseconds. The type of socket event that occurred.

Gets the interval, in milliseconds.

Defines a set of flags applicable to a instance: None (default), More, Identity, Shared

Indicates no flags are set (the default).

Indicates that more frames of the same message follow.

Indicates that this frame conveys the identity of a connected peer.

Indicates that this frame's internal data is shared with other objects.

Enumeration of possible types: Uninitialised, GC, Pool, Delimiter.

The has not yet been initialised.

The has not yet been initialised (default value).

The is empty.

The minimum valid enum value.

The data will be garbage collected when no longer needed.

The data was allocated by , and must be released back to this pool when no longer needed. This happens when is called.

The is a delimiter frame and doesn't contain any data.

Delimiters are commonly used to mark a boundary between groups frames.

The maximum valid enum value.

A Msg struct is the lowest-level interpretation of a ZeroMQ message, and simply contains byte-array data and MsgType and MsgFlags properties. It supports message buffer pooling.

Many users will not use this class directly. However in high-performance situations it may be useful. When used correctly it's possible to have zero-copy and zero-allocation behaviour.

An atomic reference count for knowing when to release a pooled data buffer back to the .

Will be null unless equals .

Set the indicated Flags bits.

which Flags bits to set (More, Identity, or Shared)

Clear the indicated Flags bits.

which Flags bits to clear (More, Identity, or Shared)

Get whether this is initialised and ready for use.

Clear this Msg to empty - ie, set MsgFlags to None, MsgType to Empty, and clear the Data.

Initialise this Msg to be of MsgType.Pool, with a data-buffer of the given number of bytes.

the number of bytes to allocate in the data-buffer

Initialise this Msg to be of MsgType.GC with the given data-buffer value.

the byte-array of data to assign to the Msg's Data property the number of bytes that are in the data byte-array

Initialise this Msg to be of MsgType.GC with the given data-buffer value.

the byte-array of data to assign to the Msg's Data property first byte in the data array the number of bytes that are in the data byte-array

Set this Msg to be of type MsgType.Delimiter with no bits set within MsgFlags.

Clear the and set the MsgType to Invalid. If this is not a shared-data Msg (MsgFlags.Shared is not set), or it is shared but the reference-counter has dropped to zero, then return the data back to the BufferPool.

The object is not initialised.

If this Msg is of MsgType.Pool, then - add the given amount number to the reference-counter and set the shared-data Flags bit. If this is not a Pool Msg, this does nothing.

the number to add to the internal reference-counter

If this Msg is of MsgType.Pool and is marked as Shared, then - subtract the given amount number from the reference-counter and, if that reaches zero - return the data to the shared-data pool. If this is not both a Pool Msg and also marked as Shared, this simply Closes this Msg.

the number to subtract from the internal reference-counter

Override the Object ToString method to show the object-type, and values of the MsgType, Size, and Flags properties.

a string that provides some detail about this Msg's state

Copy the given byte-array data to this Msg's Data buffer.

the source byte-array to copy from index within the internal Data array to copy that byte to the number of bytes to copy

Copy the given byte-array data to this Msg's Data buffer.

the source byte-array to copy from first byte in the source byte-array index within the internal Data array to copy that byte to the number of bytes to copy

Copy the given single byte to this Msg's Data buffer.

the source byte to copy from

Copy the given single byte to this Msg's Data buffer at the given array-index.

the source byte to copy from index within the internal Data array to copy that byte to

Close this Msg, and effectively make this Msg a copy of the given source Msg by simply setting it to point to the given source Msg. If this is a Pool Msg, then this also increases the reference-counter and sets the Shared bit.

the source Msg to copy from The object is not initialised.

Increase Offset and decrease Size by the given count.

Number of bytes to remove from a message

Close this Msg and make it reference the given source Msg, and then clear the Msg to empty.

the source-Msg to become The object is not initialised.

Returns a new array containing the first bytes of .

Get the number of bytes within the Data property.

Gets the position of the first element in the Data property delimited by the message, relative to the start of the original array.

Get the type of this message, from the MsgType enum.

Get whether the Delimiter bit is set on the Flags property, which would indicate that this message is intended for use simply to mark a boundary between other parts of some unit of communication.

Get whether this is initialised and ready for use.

A newly constructed is uninitialised, and can be initialised via one of , , , , or . Calling will cause the to become uninitialised again. true if the is initialised, otherwise false.

Get the flags-enum MsgFlags value, which indicates which of the More, Identity, or Shared bits are set.

Get the "Has-More" flag, which when set on a message-queue frame indicates that there are more frames to follow.

Get whether the buffer of this is shared with another instance. Only applies to pooled message types.

Get whether the Identity bit is set on the Flags property.

Get the byte-array that represents the data payload of this .

This value will be null if is , or .

Get and set the byte value in the buffer at a specific index.

The index to access

An IShimHandler provides a Run(PairSocket) method.

Execute whatever action this IShimHandler represents against the given shim.

This is an EventArgs that provides an Actor property.

Create a new NetMQActorEventArgs with the given NetMQActor.

the NetMQActor for this exception to reference

Get the NetMQActor that this exception references.

This delegate represents the action for this actor to execute.

the that is the shim to execute this action

This delegate represents the action for this actor to execute - along with a state-information object.

the type to use for the state-information object the that is the shim to execute this action the state-information that the action will use

The Actor represents one end of a two-way pipe between 2 PairSocket(s). Where the actor may be passed messages, that are sent to the other end of the pipe which called the "shim"

The terminate-shim command. This is just the literal string "endPipe".

Create a new with the given shimHandler.

an IShimHandler that provides the Run method the newly-created NetMQActor

Create a new with the action, and state-information.

a ShimAction - delegate for the action to perfrom the state-information - of the generic type T the newly-created NetMQActor

Create a new with the given .

a ShimAction - delegate for the action to perform the newly-created NetMQActor

Create a new with the given context and shimHandler.

the context for this actor to live within an IShimHandler that provides the Run method the newly-created NetMQActor

Create a new NetMQActor with the given context, action, and state-information.

the context for this actor to live within a ShimAction - delegate for the action to perfrom the state-information - of the generic type T the newly-created NetMQActor

Create a new NetMQActor with the given context and .

the context for this actor to live within a ShimAction - delegate for the action to perform the newly-created NetMQActor

Execute the shimhandler's Run method, signal ok and then dispose of the shim.

Transmit the given Msg over this actor's own socket.

the Msg to transmit this denotes any of the DontWait and SendMore flags be set The socket has been stopped. is not initialised. The send operation timed out.

Transmit the given Msg over this actor's own socket.

the Msg to transmit The maximum length of time to try and send a message. If , no wait occurs. Indicate if another frame is expected after this frame true if a message was sent, otherwise false. The socket has been stopped. is not initialised. The receive operation timed out.

Attempt to receive a message for the specified period of time, returning true if successful or false if it times-out.

a Msg to write the received message into a TimeSpan specifying how long to block, waiting for a message, before timing out true only if a message was indeed received

Release any contained resources.

true if managed resources are to be released

This event occurs when at least one message may be received from the socket without blocking.

This event occurs when a message is ready to be transmitted from the socket.

Create a new ActionShimHandler with the given type T to serve as the state-information, and the given action to operate upon that type.

a ShimAction of type T that comprises the action to perform the state-information

Perform the action upon the given shim, using our state-information.

a that is the shim to perform the action upon

Create a new ActionShimHandler with a given action to operate upon that type.

a ShimAction that comprises the action to perform

Perform the action upon the given shim, using our state-information.

a that is the shim to perform the action upon

A NetMQBeaconEventArgs is an EventArgs that provides a property that holds a NetMQBeacon.

Create a new NetMQBeaconEventArgs object containing the given NetMQBeacon.

the NetMQBeacon object to hold a reference to

Get the NetMQBeacon object that this holds.

Command to subscribe a socket to messages that have the given topic. This is valid only for Subscriber and XSubscriber sockets.

Command to un-subscribe a socket from messages that have the given topic. This is valid only for Subscriber and XSubscriber sockets.

Create a new NetMQBeacon, contained within the given context.

the NetMQContext to contain this new socket

Create a new NetMQBeacon.

Configure beacon to bind to all interfaces

Port to bind to

Configure beacon to bind to default interface

Port to bind to

Configure beacon to bind to specific interface

One of the ip address of the interface Port to bind to

Publish beacon immediately and continue to publish when interval elapsed

Beacon to transmit Interval to transmit beacon

Publish beacon immediately and continue to publish when interval elapsed

Beacon to transmit Interval to transmit beacon

Publish beacon immediately and continue to publish every second

Beacon to transmit

Publish beacon immediately and continue to publish every second

Beacon to transmit

Stop publish messages

Subscribe to beacon messages, will replace last subscribe call

Beacon will be filtered by this

Unsubscribe to beacon messages

Blocks until a string is received. As the returning of this method is uncontrollable, it's normally safer to call instead and pass a timeout.

the name of the peer, which should come before the actual message, is written to this string the string that was received

Attempt to receive a message from the specified peer for the specified amount of time.

The maximum amount of time the call should wait for a message before returning. the name of the peer that the message comes from is written to this string the string to write the received message into true if a message was received before elapsed, otherwise false.

Blocks until a message is received. As the returning of this method is uncontrollable, it's normally safer to call instead and pass a timeout.

the name of the peer, which should come before the actual message, is written to this string the byte-array of data that was received

Release any contained resources.

true if managed resources are to be released

Get the host name this beacon is bound to.

This may involve a reverse DNS lookup which can take a second or two. An empty string is returned if: the beacon is not bound, the beacon is bound to all interfaces, an error occurred during reverse DNS lookup.

Get the socket of the contained actor.

This event occurs when at least one message may be received from the socket without blocking.

Cleanup library resources, call this method when your process is shutting-down.

Set to true when you want to make sure sockets send all pending messages

Get or set the default linger period for the all sockets, which determines how long pending messages which have yet to be sent to a peer shall linger in memory after a socket is closed.

This also affects the termination of the socket's context. -1: Specifies infinite linger period. Pending messages shall not be discarded after the socket is closed; attempting to terminate the socket's context shall block until all pending messages have been sent to a peer. 0: The default value of 0 specifies an no linger period. Pending messages shall be discarded immediately when the socket is closed. Positive values specify an upper bound for the linger period. Pending messages shall not be discarded after the socket is closed; attempting to terminate the socket's context shall block until either all pending messages have been sent to a peer, or the linger period expires, after which any pending messages shall be discarded.

Get or set the number of IO Threads NetMQ will create, default is 1. 1 is good for most cases.

Get or set the maximum number of sockets.

NetMQContext is an old concept and is no longer needed. You can create sockets with new keyword, for example new RequestSocket(); Please note that when creating socket with new keyword the default value for SocketOptions.Linger is zero and not indefinitly like with context. NetMQContext is the context class of the NetMQ message-queueing subsystem. This contains all of the state-information for the message-queueing subsystem, and provides methods for socket creation. You should (ordinarily) have only one context in your application process.

The NetMQContext is used to create all sockets. Thus, to use NetMQ you should start by calling NetMQContext.Create() to create an instance. NetMQContext is an IDisposable so you can use it within a using block:


            using (var context = NetMQContext.Create())
            {
                // Put your code in here. Exit this block to dispose the context
                // only when communication is no longer required.
            }

You should create and use exactly one context in your process.

Create and return a new context.

the new NetMQContext

Create a socket of the given type within this context.

a ZmqSocketType denoting which type of socket to create a new socket of the given type

Create and return a new socket of the given socketType.

a ZmqSocketType indicating the type of socket to create a new socket - a subclass of NetMQSocket The socketType must be a valid value.

Create and return a new request-socket.

the new RequestSocket

Create and return a new response-socket.

the new ResponseSocket

Create and return a new dealer-socket.

the new DealerSocket

Create and return a new router-socket.

the new RouterSocket

Create and return a new xpublisher-socket.

the new XPublisherSocket

Create and return a new pair-socket.

the new PairSocket

Create and return a new push-socket.

the new PushSocket

Create and return a new publisher-socket.

the new PublisherSocket

Create and return a new pull-socket.

the new PullSocket

Create and return a new subscriber-socket.

the new SubscriberSocket

Create and return a new xsubscriber-socket.

the new XSubscriberSocket

Create and return a new stream-socket.

the new StreamSocket

Create and return a new monitor-socket that monitors the given endpoint.

a string denoting the endpoint to be monitored the new NetMQMonitor endpoint must not be null. endpoint must not be an empty string.

Close (terminate) this context.

May be safely called even if already terminated. This must not be called on a context that is already closed otherwise an ObjectDisposedException is thrown.

Close (or terminate) this context.

true if releasing managed resources

Get or set the number of IO Threads in the context, default is 1. 1 is good for most cases.

Get or set the maximum number of sockets.

Should context wait for all sockets before terminating?

Base class for custom exceptions within the NetMQ library.

Constructor for serialisation.

Create a new NetMQException containing the given Exception, Message and ErrorCode.

an Exception that this exception will expose via it's InnerException property the textual description of what gave rise to this exception, to expose via the Message property an ErrorCode that this exception will expose via its ErrorCode property

Create and return a new NetMQException with no Message containing only the given SocketException.

a SocketException that this exception will expose via its InnerException property a new NetMQException

Create and return a new NetMQException with no Message containing the given SocketError and Exception.

a SocketError that this exception will carry and expose via its ErrorCode property an Exception that this exception will expose via its InnerException property a new NetMQException

Create and return a new NetMQException with no Message containing the given ErrorCode and Exception.

an ErrorCode for this exception to contain and expose via its ErrorCode property an Exception for this exception to contain and expose via its InnerException property a new NetMQException

Create and return a new NetMQException with no Message containing only the given ErrorCode.

an ErrorCode that this exception will carry and expose via its ErrorCode property a new NetMQException

Create and return a new NetMQException with the given Message and ErrorCode.

the textual description of what gave rise to this exception, to expose via the Message property an ErrorCode that this exception will carry and expose via its ErrorCode property a new NetMQException

Create and return a new NetMQException with the given ErrorCode, Message, and Exception.

an ErrorCode that this exception will contain and expose via its ErrorCode property the textual description of what gave rise to this exception, to expose via the Message property an Exception that this exception will expose via its InnerException property a new NetMQException, or subclass of NetMQException that corresponds to the given ErrorCode

AddressAlreadyInUseException is a NetMQException that is used within SocketBase.Bind to signal an address-conflict.

Create a new AddressAlreadyInUseException with a given inner-exception and message.

an Exception for this new exception to contain and expose via its InnerException property the textual description of what gave rise to this exception, to expose via the Message property

Create a new AddressAlreadyInUseException with a given message.

the textual description of what gave rise to this exception, to expose via the Message property

Constructor for serialisation.

EndpointNotFoundException is a NetMQException that is used within Ctx.FindEndpoint to signal a failure to find a specified address.

Create a new EndpointNotFoundException with a given inner-exception and message.

an Exception for this new exception to contain and expose via its InnerException property the textual description of what gave rise to this exception, to expose via the Message property

Create a new EndpointNotFoundException with a given message.

the textual description of what gave rise to this exception, to expose via the Message property

Create a new EndpointNotFoundException with no message nor inner-exception.

Constructor for serialisation.

AgainException is a NetMQException that is used within SocketBase.Send and SocketBase.Recv to signal failures (as when the Send/Receive fails and DontWait is set or no timeout is specified) and is raised within Sub.XSetSocketOption if sending the queued-message fails.

Create a new AgainException with a given inner-exception and message.

an Exception for this new exception to contain and expose via its InnerException property the textual description of what gave rise to this exception, to expose via the Message property

Create a new AgainException with no message nor inner-exception.

Constructor for serialisation.

TerminatingException is a NetMQException that is used within SocketBase and Ctx to signal that you're making the mistake of trying to do further work after terminating the message-queueing system.

Create a new TerminatingException with a given inner-exception and message.

an Exception for this new exception to contain and expose via its InnerException property the textual description of what gave rise to this exception, to expose via the Message property

Create a new TerminatingException with no message nor inner-exception.

Constructor for serialisation.

InvalidException is a NetMQException that is used within the message-queueing system to signal invalid value errors.

Create a new InvalidException with a given inner-exception and message.

an Exception for this new exception to contain and expose via its InnerException property the textual description of what gave rise to this exception, to expose via the Message property

Create a new InvalidException with the given message.

the textual description of what gave rise to this exception, to expose via the Message property

Create a new InvalidException with no message nor inner-exception.

Constructor for serialisation.

FaultException is a NetMQException that is used within within the message-queueing system to signal general fault conditions.

Create a new FaultException with a given inner-exception and message.

an Exception for this new exception to contain and expose via its InnerException property the textual description of what gave rise to this exception, to expose via the Message property

Create a new FaultException with the given message.

the textual description of what gave rise to this exception, to expose via the Message property

Create a new FaultException with no message nor inner-exception.

Constructor for serialisation.

ProtocolNotSupportedException is a NetMQException that is used within the message-queueing system to signal mistakes in properly utilizing the communications protocols.

Create a new ProtocolNotSupportedException with a given inner-exception and message.

an Exception for this new exception to contain and expose via its InnerException property the textual description of what gave rise to this exception, to expose via the Message property

Create a new ProtocolNotSupportedException with the given message.

the textual description of what gave rise to this exception, to expose via the Message property

Create a new ProtocolNotSupportedException with no message nor inner-exception.

Constructor for serialisation.

HostUnreachableException is an Exception that is used within within the message-queueing system to signal failures to communicate with a host.

Create a new HostUnreachableException with a given inner-exception and message.

an Exception for this new exception to contain and expose via its InnerException property the textual description of what gave rise to this exception, to expose via the Message property

Create a new HostUnreachableException with the given message.

the textual description of what gave rise to this exception, to expose via the Message property

Create a new HostUnreachableException with no message nor inner-exception.

Constructor for serialisation.

FiniteStateMachineException is an Exception that is used within the message-queueing system to signal errors in the send/receive order with request/response sockets.

Create a new FiniteStateMachineException with a given inner-exception and message.

an Exception for this new exception to contain and expose via its InnerException property the textual description of what gave rise to this exception, to expose via the Message property

Create a new FiniteStateMachineException with the given message.

the textual description of what gave rise to this exception, to expose via the Message property

Create a new FiniteStateMachineException with no message nor inner-exception.

Constructor for serialisation.

Objects of class NetMQFrame serve to hold a Buffer (that consists of a byte-array containing a unit of a message-queue message) and provide methods to construct it given a string and an encoding.

This is the length of the byte-array data buffer.

This holds the computed hash-code for this object.

Create a new NetMQFrame containing the given byte-array data.

a byte-array to hold as the frame's data

Create a new NetMQFrame containing the given string-message, using the default ASCII encoding.

a string containing the message-data of the frame

Create a new NetMQFrame containing the given string-message, using the given encoding to convert it into a byte-array.

a string containing the message-data of the frame the Encoding to use to convert the given string-message into the internal byte-array

Create a new NetMQFrame with a data-buffer pre-sized to the given length.

the number of bytes to allocate for the data-buffer length must be non-negative (zero or positive).

Create and return a new NetMQFrame with a copy of the supplied byte-array buffer.

the byte-array to copy into the new NetMQFrame a new containing a copy of the supplied byte-array is null.

Return this frame's data-buffer converted into a string, using the default ASCII encoding.

the data buffer converted to a string

Return this frame's data-buffer converted into a string using the given encoding.

the Encoding to use to convert the internal byte-array buffer into a string the data buffer converted to a string

Convert the buffer to integer in network byte order (big-endian)

Convert the buffer to long in network byte order (big-endian)

Create a deep-copy of the supplied .

the to copy a containing a copy of is null.

Create a deep-copy of this NetMQFrame and return it.

a new NetMQFrame containing a copy of this one's buffer data

Return true if the buffer of this NetMQFrame is equal to the given byte-array.

a byte-array buffer to compare this frame against

Determine whether the specified is equal to the current .

the to compare with the current . true if the specified NetMQFrame is equal to this one; otherwise, false

Return true if the given Object is a NetMQFrame which has a Buffer that is identical to that of this one.

the Object to compare this to true only if the given Object is a NetMQFrame equal to this one

Return true if this one and the other NetMQFrame are equal, or both are null.

one frame to compare against the other the other frame to compare true if both frames are equal

Return true if this one and the other NetMQFrame NOT are equal.

one frame to compare against the other the other frame to compare false if both frames are equal

Override the Object.GetHashCode method to return a hash-code derived from the content of the Buffer. That is only computed the first time this method is called.

an integer that represents the computed hash-code

Return an array of bytes that carries the content of this NetMQFrames Buffer.

if this argument is true - a new copy is made if BufferSize is equal to MessageSize the Buffer as a byte-array, either newly-allocated or else (if copy is false) simply a reference to the actual Buffer

Get or set the size of the message data contained in the frame, which here represents the number of bytes.

The value must be between zero and BufferSize.

Get the underlying frame-data buffer, which is an array of bytes.

Get the maximum size of the frame-data buffer (ie, the number of bytes of the array).

Get a new empty that may be used as message separators.

Get whether this NetMQFrame is empty - that is, has a Buffer of zero-length.

This namespace encompasses the NetMQ message-queueing library and attendant utility software.

A NetMQMessage is basically a collection of NetMQFrames, and is the basic message-unit that is sent and received across this message-queueing subsystem.

This is the frame-stack that comprises the message-content of this message.

The default-constructor for NetMQMessage: create a new instance of NetMQMessage with an empty frame-stack.

Create a new instance of a NetMQMessage that contains the given collection of NetMQFrames as its frame-stack.

a collection of NetMQFrames, to form the frame-stack The value of 'frames' cannot be null.

Create a new instance of a NetMQMessage that contains the given collection of byte-arrays as its frame-stack.

a collection of byte-array buffers, to form the frame-stack The value of 'buffers' cannot be null.

Add the given NetMQFrame to this NetMQMessage, at the highest-indexed position of the frame-stack.

a NetMQFrame object comprising the frame to be appended onto the frame-stack

Add the given data (in this case a byte-array) to this NetMQMessage, at the highest-indexed position of the frame-stack. Data is not copied.

a byte-array containing the message to append onto the frame-stack of this NetMQMessage

Add the given string - which gets converted into a NetMQFrame - onto the highest-indexed position of the frame-stack of this NetMQMessage.

a string containing the message to append onto the frame-stack of this NetMQMessage

Add the given string - which gets converted into a NetMQFrame - onto the highest-indexed position of the frame-stack of this NetMQMessage.

a string containing the message to append onto the frame-stack of this NetMQMessage an Encoding that specifies how to convert the string into bytes

Convert the given integer value into an array of bytes and add it as a new frame onto this NetMQMessage.

a 32-bit integer value that is to be converted into bytes and added to this message

Convert the given long value into an array of bytes and add it as a new frame onto this NetMQMessage.

a 64-bit number that is to be converted into bytes and added to this message

Add the Data of the given Blob, as a new frame, onto this NetMQMessage.

the Blob whose data is to be added as a new frame

Add an empty frame to this NetMQMessage.

Push the given NetMQFrame into the frame-stack of this NetMQMessage.

the NetMQFrame to be inserted into the frame-stack The concept is the same as pushing an element onto a stack. This inserts the given NetMQFrame into the lowest-indexed position of this NetMQMessage, pushing all of the other frames upward in index-position.

Push a new frame containing the given byte-array into the frame-stack of this NetMQMessage.

the byte-array to create a new frame from The concept is the same as pushing an element onto a stack. This creates a new frame from the given data (in this case a byte-array) and inserts it into the lowest-indexed position of the collection of frames of this NetMQMessage, pushing all of the other frames upward in index-position.

Push a new frame containing the given string (converted into a byte-array) into the frame-stack of this NetMQMessage.

the string to create a new frame from The concept is the same as pushing an element onto a stack. This creates a new frame from the given data (in this case a string which gets converted into a byte-array using the default ASCII encoding) and inserts it into the lowest-indexed position of the collection of frames of this NetMQMessage, pushing all of the other frames upward in index-position.

Push a new frame containing the given string (converted into a byte-array) into the frame-stack of this NetMQMessage.

the string to create a new frame from the Encoding that dictates how to encode the string into bytes The concept is the same as pushing an element onto a stack. This creates a new frame from the given data (in this case a string which gets converted into a byte-array using the given Encoding) and inserts it into the lowest-indexed position of the collection of frames of this NetMQMessage, pushing all of the other frames upward in index-position.

Push a new frame containing the given integer (converted into a byte-array) into the frame-stack of this NetMQMessage.

the integer to create a new frame from The concept is the same as pushing an element onto a stack. This creates a new frame from the given data (in this case a 32-bit integer which gets converted into a byte-array in big-endian order) and inserts it into the lowest-indexed position of the collection of frames of this NetMQMessage, pushing all of the other frames upward in index-position.

Push a new frame containing the given long (converted into a byte-array) into the frame-stack of this NetMQMessage.

the 64-bit number to create a new frame from The concept is the same as pushing an element onto a stack. This creates a new frame from the given data (in this case a 64-bit long which gets converted into a byte-array in big-endian order) and inserts it into the lowest-indexed position of the collection of frames of this NetMQMessage, pushing all of the other frames upward in index-position.

Push a new frame containing the given Data of the given Blob, into the frame-stack of this NetMQMessage.

the Blob to create a new frame from The concept is the same as pushing an element onto a stack. This creates a new frame from the given data (in this case taken from the Data property of the Blob) and inserts it into the lowest-indexed position of the collection of frames of this NetMQMessage, pushing all of the other frames upward in index-position.

Push an empty frame (a NetMQFrame.Empty) onto the frame-stack.

Remove and return the first frame.

the first frame, which was popped - which is the frame from the lowest-indexed position

Delete the given frame from the frame-stack.

the frame to remove true if removed, otherwise false.

Clear (empty) the frame-stack, so that it no longer contains any frames.

Return an enumerator over the frames contained within this message.

an IEnumerator over the frames in this message

Return an enumerator over the frames contained within this message.

an IEnumerator over the frames in this message

Returns a string showing the frame contents.

Gets the first frame in the current message.

Gets the last frame in the current message.

Gets a value indicating whether the current message is empty.

Gets the number of objects contained by this message.

Gets the at the specified index.

The zero-based index of the to get. The at the specified index. is less than 0 -or- is equal to or greater than .

Not supported.

Always thrown.

Runs the poller in a background thread, returning immediately.

Runs the poller on the caller's thread. Only returns when or are called from another thread.

Stops the poller, blocking until stopped.

Stops the poller, returning immediately and most likely before the poller has actually stopped.

This class only implements in order to support collection initialiser syntax.

An empty enumerator.

Stops and disposes the poller. The poller may not be used once disposed.

Get whether the caller is running on the scheduler's thread. If true, the caller can execute tasks directly (inline). If false, the caller must start a on this scheduler.

This property enables avoiding the creation of a object and potential delays to its execution due to queueing. In most cases this is just an optimisation.


            if (scheduler.CanExecuteTaskInline)
            {
                socket.Send(...);
            }
            else
            {
                var task = new Task(() => socket.Send(...));
                task.Start(scheduler);
            }

Returns 1, as runs a single thread and all tasks must execute on that thread.

Get whether this object is currently polling its sockets and timers.

Dispatches an asynchronous message to a synchronization context.

Dispatches a synchronous message to a synchronization context.

Class to quickly handle incoming messages of socket. New thread is created to handle the messages. Call dispose to stop the thread. Provided socket will not be disposed by the class.

Create NetMQProactor and start dedicate thread to handle incoming messages.

Socket to handle messages from Handler to handle incoming messages

Stop the proactor. Provided socket will not be disposed.

Multi producer singler consumer queue which you can poll on with a Poller.

Type of the item in queue

Create new NetMQQueue.

The capacity of the queue, use zero for unlimited

Try to dequeue an item from the queue. Dequeueing and item is not thread safe.

Will be filled with the item upon success Timeout to try and dequeue and item Will return false if it didn't succeed to dequeue an item after the timeout.

Dequeue an item from the queue, will block if queue is empty. Dequeueing and item is not thread safe.

Dequeued item

Enqueue an item to the queue, will block if the queue is full.

Dispose the queue.

Register for this event for notification when there are items in the queue. Queue must be added to a poller for this to work.

True if we own m_poller (that is, it was created within the NetMQScheduler constructor as opposed to being passed-in from the caller).

Create a new NetMQScheduler object within the given context, and optionally using the given poller.

the NetMQContext to create this NetMQScheduler within (optional)the Poller for this Net to use

Create a new NetMQScheduler object within the given context, and optionally using the given poller.

(optional)the Poller for this Net to use

Return a collection of the scheduled Tasks. (Not supported - for debug purposes only)

Release any contained resources.

set this to true if releasing managed resources

Get whether the caller is running on the scheduler's thread. If true, the caller can execute tasks directly (inline). If false, the caller must start a on this scheduler.

This property enables avoiding the creation of a object and potential delays to its execution due to queueing. In most cases this is just an optimisation.


            if (scheduler.CanExecuteTaskInline)
            {
                socket.Send(...);
            }
            else
            {
                var task = new Task(() => socket.Send(...));
                task.Start(scheduler);
            }

Get the maximum level of concurrency used in the scheduling. This is simply the value 1, and is not presently used anywhere within NetMQ.

Abstract base class for NetMQ's different socket types.

Various options are available in this base class, though their affect can vary by socket type.

Create a new NetMQSocket with the given .

Type of socket to create

Create a new NetMQSocket with the given .

a SocketBase object to assign to the new socket

Raise the event.

Bind the socket to .

a string representing the address to bind this socket to thrown if the socket was already disposed The socket has been stopped. The specified address is already in use. No IO thread was found, or the protocol's listener encountered an error during initialisation.

Binds the specified TCP to an available port, assigned by the operating system.

the chosen port-number thrown if the socket was already disposed uses a protocol other than TCP. The socket has been stopped. The specified address is already in use. No IO thread was found, or the protocol's listener errored during initialisation.

Connect the socket to .

a string denoting the address to connect this socket to thrown if the socket was already disposed The socket has been stopped. No IO thread was found. The specified address is already in use.

Disconnect this socket from .

a string denoting the address to disconnect from thrown if the socket was already disposed The socket has been stopped. Endpoint was not found and cannot be disconnected.

Unbind this socket from .

a string denoting the address to unbind from thrown if the socket was already disposed The socket has been stopped. Endpoint was not found and cannot be disconnected.

Closes this socket, rendering it unusable. Equivalent to calling .

Wait until a message is ready to be received from the socket.

Wait until a message is ready to be received/sent from this socket or until timeout is reached. If a message is available, the ReceiveReady/SendReady event is fired.

a TimeSpan that represents the timeout-period true if a message was available within the timeout, false otherwise

Poll this socket, which means wait for an event to happen within the given timeout period.

the poll event(s) to listen for the timeout period PollEvents.None -> no message available PollEvents.PollIn -> at least one message has arrived PollEvents.PollOut -> at least one message is ready to send PollEvents.Error -> an error has occurred or any combination thereof The internal select operation failed. The socket has been stopped.

Return a value that indicates which bit-flags have a corresponding listener, with PollError always set, and PollOut set based upon m_sendReady and PollIn set based upon m_receiveReady.

a PollEvents value that denotes which events have a listener

Unless this socket is closed, based upon the given PollEvents - raise the m_receiveReady event if PollIn is set, and m_sendReady if PollOut is set.

what to use as the source of the events the given PollEvents that dictates when of the two events to raise

Receive the next message from this socket.

Whether the request blocks or not is controlled by . The Msg object to put it in Either , or . is ignored. The receive operation timed out.

Attempt to receive a message for the specified amount of time.

A reference to a instance into which the received message data should be placed. The maximum amount of time the call should wait for a message before returning. true if a message was received before elapsed, otherwise false.

Send the given Msg out upon this socket. The message content is in the form of a byte-array that Msg contains.

the Msg struct that contains the data and the options for this transmission a SendReceiveOptions value that can specify the DontWait or SendMore bits (or None) The socket has been stopped. is not initialised. The send operation timed out.

Send a message if one is available within .

Subscribe this socket to messages that have the given topic. This is valid only for Subscriber and XSubscriber sockets.

a string denoting the topic to subscribe to You subscribe a socket to a given topic when you want that socket to receive messages of that topic. A topic is simply a specific prefix (in the form of a byte-array or the equivalent text). This is valid only for Subscriber and XSubscriber sockets.

Subscribe this socket to messages that have the given topic. This is valid only for Subscriber and XSubscriber sockets.

a byte-array denoting the topic to subscribe to You subscribe a socket to a given topic when you want that socket to receive messages of that topic. A topic is simply a specific prefix (in the form of a byte-array or the equivalent text). This is valid only for Subscriber and XSubscriber sockets.

Un-subscribe this socket from the given topic. This is valid only for Subscriber and XSubscriber sockets.

a string denoting the topic to unsubscribe from You un-subscribe a socket from the given topic when you no longer want that socket to receive messages of that topic. A topic is simply a specific prefix (in the form of a byte-array or the equivalent text). This is valid only for Subscriber and XSubscriber sockets.

Un-subscribe this socket from the given topic. This is valid only for Subscriber and XSubscriber sockets.

a byte-array denoting the topic to unsubscribe from You un-subscribe a socket from the given topic when you no longer want that socket to receive messages of that topic. A topic is simply a specific prefix (in the form of a byte-array or the equivalent text). This is valid only for Subscriber and XSubscriber sockets.

Listen to the given endpoint for SocketEvent events.

A string denoting the endpoint to monitor The specific events to report on. Defaults to if ommitted. is null. cannot be empty or whitespace. This object is already disposed. The protocol of is not supported. The socket has been stopped. Maximum number of sockets reached.

Listen to the given endpoint for SocketEvent events.

Get the integer-value of the specified .

a ZmqSocketOption that specifies what to get an integer that is the value of that option The socket has been stopped. This object is already disposed.

Get the (generically-typed) value of the specified .

a ZmqSocketOption that specifies what to get an object of the given type, that is the value of that option The socket has been stopped. This object is already disposed.

Get the value of the specified ZmqSocketOption.

a ZmqSocketOption that specifies what to get a TimeSpan that is the value of that option The socket has been stopped.

Get the 64-bit integer-value of the specified .

a ZmqSocketOption that specifies what to get a long that is the value of that option The socket has been stopped.

Assign the given integer value to the specified .

a ZmqSocketOption that specifies what to set an integer that is the value to set that option to The socket has been stopped. This object is already disposed.

Assign the given TimeSpan to the specified .

a ZmqSocketOption that specifies what to set a TimeSpan that is the value to set that option to The socket has been stopped.

Assign the given Object value to the specified .

a ZmqSocketOption that specifies what to set an object that is the value to set that option to The socket has been stopped. This object is already disposed.

Closes this socket, rendering it unusable. Equivalent to calling .

true if releasing managed resources

This event occurs when at least one message may be received from the socket without blocking.

This event is raised when a is added to a running .

This event occurs when at least one message may be sent via the socket without blocking.

This event is raised when a is added to a running .

Fires when either the or event is set.

Get or set an integer that represents the number of errors that have accumulated.

Get the of this socket.

Get the underlying .

Get whether a message is waiting to be picked up (true if there is, false if there is none).

The socket has been stopped.

Get whether a message is waiting to be sent.

This is true if at least one message is waiting to be sent, false if there is none. The socket has been stopped.

This subclass of EventArgs contains a NetMQSocket, and IsReadyToReceive and IsReadyToSend flags to indicate whether ready to receive or send.

Create a new NetMQSocketEventArgs referencing the given socket.

the NetMQSocket that this is in reference to

Initialise the ReceiveReady and SendReady flags from the given PollEvents value.

a PollEvents value that indicates whether the socket is ready to send or receive without blocking

Get the NetMQSocket that this references.

Get whether at least one message may be received by the socket without blocking.

Get whether at least one message may be sent by the socket without blocking.

Get whether at least one message may be received by the socket without blocking.

Get whether at least one message may be sent by the socket without blocking.

Class NetMQTimerEventArgs is an EventArgs that contains a reference to a NetMQTimer.

Create a new NetMQTimerEventArgs that contains a reference to the given NetMQTimer.

the NetMQTimer to hold a reference to

Get the NetMQTimer that this has a reference to.

A NetMQTimer instance provides the state-information for a timer function, which is periodically checked by a Poller or a NetMQBeacon.

A pre-constructed NetMQTimerEventArgs to use whenever raising the Elapsed event.

This is the timer-interval in milliseconds.

This flag dictates whether this timer is currently enabled.

Create a new NetMQTimer with the timer-interval specified by the given TimeSpan.

a TimeSpan that denotes the timer-interval This sets the When property to an initial value of -1, to indicate it no future-time applies as yet.

Create a new NetMQTimer with the given timer-interval in milliseconds.

an integer specifying the timer-interval in milliseconds This sets the When property to an initial value of -1, to indicate it no future-time applies as yet.

Enable the timer and reset the interval

If there are any subscribers - raise the Elapsed event.

the sender to include within the event's event-args

This event is used to signal when the timer has expired.

Get or set the timer-interval, in milliseconds.

When setting this, When is set to the future point in time from now at which the interval will expire (or -1 if not Enabled).

Get or set whether this NetMQTimer is on.

When setting this to true, When is set to the future point in time from now at which the interval will expire. When setting this to false, When is set to -1.

Get or set the value of the low-precision timestamp (a value in milliseconds) that signals when the timer is to expire, or -1 if not applicable at this time.

This static class serves to convert between byte-arrays, and various integer sizes - all of which assume the byte-data is in Big-endian, or "Network Byte Order".

Given a byte-array assumed to be in Big-endian order, and an offset into it - return a 16-bit integer derived from the 2 bytes starting at that offset.

the byte-array to get the short from

Given a 16-bit integer, return it as a byte-array in Big-endian order.

the short to convert a 2-byte array containing that short's bits

Given a 16-bit integer, and a byte-array buffer and offset, - write the 2 bytes of that integer into the buffer starting at that offset, in Big-endian order.

the short to convert into bytes the byte-array to write the short's bytes into

Given a byte-array assumed to be in Big-endian order, and an offset into it - return a 32-bit integer derived from the 4 bytes starting at that offset.

the byte-array to get the integer from

Given a 32-bit integer, return it as a byte-array in Big-endian order.

the int to convert a 4-byte array containing that integer's bits

Given a 32-bit integer, and a byte-array buffer and offset, - write the 4 bytes of that integer into the buffer starting at that offset, in Big-endian order.

the integer to convert into bytes the byte-array to write the integer's bytes into

Given a byte-array assumed to be in Big-endian order, and an offset into it - return a 64-bit integer derived from the 8 bytes starting at that offset.

the byte-array to get the Int64 from

Given a 64-bit integer, return it as a byte-array in Big-endian order.

The long value to convert from. The network order presentation of as an 8-byte array.

Given a 64-bit integer, and a byte-array buffer and offset, - write the 8 bytes of that integer into the buffer starting at that offset, in Big-endian order.

the long value to convert into bytes the byte-array to write the long value's bytes into

This static class serves to provide extension methods for IOutgoingSocket.

Block until the message is can be sent.

The call blocks until the message can be sent and cannot be interrupted. Wether the message can be sent depends on the socket type. The socket to send the message on. An object with message's data to send. Indicate if another frame is expected after this frame

Transmit a byte-array of data over this socket, block until frame is sent.

the IOutgoingSocket to transmit on the byte-array of data to send set this flag to true to signal that you will be immediately sending another frame (optional: default is false)

Transmit a byte-array of data over this socket, block until frame is sent.

the IOutgoingSocket to transmit on the byte-array of data to send the number of bytes to send from . set this flag to true to signal that you will be immediately sending another frame (optional: default is false)

Transmit a byte-array of data over this socket, block until frame is sent. Send more frame, another frame must be sent after this frame. Use to chain Send methods.

the IOutgoingSocket to transmit on the byte-array of data to send a reference to this IOutgoingSocket so that method-calls may be chained together

Transmit a byte-array of data over this socket, block until frame is sent. Send more frame, another frame must be sent after this frame. Use to chain Send methods.

the IOutgoingSocket to transmit on the byte-array of data to send the number of bytes to send from . a reference to this IOutgoingSocket so that method-calls may be chained together

Attempt to transmit a single frame on . If message cannot be sent within , return false.

the IOutgoingSocket to transmit on The maximum period of time to try to send a message. the byte-array of data to send the number of bytes to send from . set this flag to true to signal that you will be immediately sending another frame (optional: default is false) true if a message was available, otherwise false.

Attempt to transmit a single frame on . If message cannot be sent within , return false.

the IOutgoingSocket to transmit on The maximum period of time to try to send a message. the byte-array of data to send set this flag to true to signal that you will be immediately sending another frame (optional: default is false) true if a message was available, otherwise false.

Attempt to transmit a single frame on . If message cannot be sent immediately, return false.

the IOutgoingSocket to transmit on the byte-array of data to send set this flag to true to signal that you will be immediately sending another frame (optional: default is false) true if a message was available, otherwise false.

Attempt to transmit a single frame on . If message cannot be sent immediately, return false.

Transmit a byte-array of data over this socket.

the IOutgoingSocket to transmit on the byte-array of data to send the number of bytes to send from . options to control how the data is sent

Transmit a byte-array of data over this socket.

the IOutgoingSocket to transmit on the byte-array of data to send the number of bytes to send if true, return immediately without waiting for the send operation to complete (optional: default is false) set this flag to true to signal that you will be immediately sending another message (optional: default is false)

Transmit a byte-array of data over this socket.

the IOutgoingSocket to transmit on the byte-array of data to send

Transmit a string-message of data over this socket, while indicating that more is to come (the SendMore flag is set to true).

the IOutgoingSocket to transmit on the byte-array of data to send if true, return immediately without waiting for the send operation to complete (optional: default is false) a reference to this IOutgoingSocket so that method-calls may be chained together

Transmit a string-message of data over this socket, while indicating that more is to come (the SendMore flag is set to true).

the IOutgoingSocket to transmit on the byte-array of data to send the number of bytes to send if true, return immediately without waiting for the send operation to complete (optional: default is false) a reference to this IOutgoingSocket so that method-calls may be chained together

Send multiple frames on , blocking until all frames are sent.

the IOutgoingSocket to transmit on frames to transmit

Send multiple frames on , blocking until all frames are sent.

the IOutgoingSocket to transmit on frames to transmit

Attempt to transmit a mulitple frames on . If frames cannot be sent within , return false.

the IOutgoingSocket to transmit on The maximum period of time to try to send a message. frames to transmit

Attempt to transmit a mulitple frames on . If frames cannot be sent within , return false.

the IOutgoingSocket to transmit on The maximum period of time to try to send a message. frames to transmit

Attempt to transmit a mulitple frames on . If frames cannot be sent immediatly, return false.

the IOutgoingSocket to transmit on frames to transmit

Attempt to transmit a mulitple frames on . If frames cannot be sent immediatly, return false.

the IOutgoingSocket to transmit on frames to transmit

Transmit a string over this socket, block until frame is sent.

the IOutgoingSocket to transmit on the string to send set this flag to true to signal that you will be immediately sending another frame (optional: default is false)

Transmit a string over this socket, block until frame is sent. Send more frame, another frame must be sent after this frame. Use to chain Send methods.

the IOutgoingSocket to transmit on the string to send a reference to this IOutgoingSocket so that method-calls may be chained together

Attempt to transmit a single string frame on . If message cannot be sent within , return false.

the IOutgoingSocket to transmit on The maximum period of time to try to send a message. the string to send set this flag to true to signal that you will be immediately sending another frame (optional: default is false) true if a message was available, otherwise false.

Attempt to transmit a single string frame on . If message cannot be sent immediately, return false.

the IOutgoingSocket to transmit on the string to send set this flag to true to signal that you will be immediately sending another frame (optional: default is false) true if a message was available, otherwise false.

Transmit a string-message of data over this socket. The string will be encoded into bytes using the specified Encoding.

the IOutgoingSocket to transmit on a string containing the message to send the Encoding to use when converting the message-string into bytes use this to specify which of the DontWait and SendMore flags to set

Transmit a string-message of data over this socket. The string will be encoded into bytes using the specified Encoding.

the IOutgoingSocket to transmit on a string containing the message to send the Encoding to use when converting the message-string into bytes if true, return immediately without waiting for the send operation to complete (optional: default is false) set this flag to true to signal that you will be immediately sending another message (optional: default is false)

Transmit a string-message of data over this socket. The string will be encoded into bytes using the default Encoding (ASCII).

the IOutgoingSocket to transmit on a string containing the message to send if true, return immediately without waiting for the send operation to complete (optional: default is false) set this flag to true to signal that you will be immediately sending another message (optional: default is false)

Transmit a string-message of data over this socket, while indicating that more is to come (the SendMore flag is set to true).

the IOutgoingSocket to transmit on a string containing the message to send if true, return immediately without waiting for the send operation to complete a reference to this IOutgoingSocket so that method-calls may be chained together

Transmit a string-message of data over this socket and also signal that you are sending more. The string will be encoded into bytes using the specified Encoding.

the IOutgoingSocket to transmit on a string containing the message to send the Encoding to use when converting the message-string into bytes if true, return immediately without waiting for the send operation to complete (optional: default is false) a reference to this IOutgoingSocket so that method-calls may be chained together

Send multiple message on , blocking until all entire message is sent.

the IOutgoingSocket to transmit on message to transmit

Attempt to transmit a mulitple message on . If message cannot be sent within , return false.

the IOutgoingSocket to transmit on The maximum period of time to try to send a message. message to transmit

Attempt to transmit a mulitple message on . If frames cannot be sent immediatly, return false.

the IOutgoingSocket to transmit on message to transmit

Transmit a message over this socket.

the IOutgoingSocket to transmit on the NetMQMessage that contains the frames of data to send if true, return immediately without waiting for the send operation to complete (optional: default is false)

Transmit an empty frame over this socket, block until frame is sent.

the IOutgoingSocket to transmit on set this flag to true to signal that you will be immediately sending another frame (optional: default is false)

Transmit an empty frame over this socket, block until frame is sent. Send more frame, another frame must be sent after this frame. Use to chain Send methods.

the IOutgoingSocket to transmit on a reference to this IOutgoingSocket so that method-calls may be chained together

Attempt to transmit an empty frame on . If message cannot be sent within , return false.

the IOutgoingSocket to transmit on The maximum period of time to try to send a message. set this flag to true to signal that you will be immediately sending another frame (optional: default is false) true if a message was available, otherwise false.

Attempt to transmit an empty frame on . If message cannot be sent immediately, return false.

the IOutgoingSocket to transmit on set this flag to true to signal that you will be immediately sending another frame (optional: default is false) true if a message was available, otherwise false.

Transmit a status-signal over this socket.

the IOutgoingSocket to transmit on a byte that contains the status signal to send

Attempt to transmit a status-signal over this socket. If signal cannot be sent immediately, return false.

the IOutgoingSocket to transmit on a byte that contains the status signal to send

Transmit a specific status-signal over this socket that indicates OK.

the IOutgoingSocket to transmit on

Attempt to transmit a specific status-signal over this socket that indicates OK. If signal cannot be sent immediately, return false.

the IOutgoingSocket to transmit on

Transmit a specific status-signal over this socket that indicates there is an error.

the IOutgoingSocket to transmit on

Attempt to transmit a specific status-signal over this socket that indicates there is an error. If signal cannot be sent immediately, return false.

the IOutgoingSocket to transmit on

The Poller class provides for managing a set of one or more sockets and being alerted when one of them has a message ready.

This is the list of sockets that this Poller is listening to.

A Dictionary of entries each of which associates a socket with an action.

An array of sockets that are active.

This is the list of NetMQTimers.

This is used to hold the list of expired timers.

Flag used to signal completion of the loop.

Switch indicate if the poller is on or off.

When true, this indicates that there may be fresh socket-events to be polled-for. This is set true whenever a EventsChanged event is received from any of the contained sockets.

This flag is used to mark this poller as disposed when the Dispose method is called, to guard against further operations on this poller-object.

Create a new Poller object, with a default PollTimeout of 1 second.

Create a new Poller object with an array of sockets.

an array of ISocketPollables to poll sockets must not be null.

Create a new Poller object with the given array of timers.

an array of NetMQTimers (must not be null) to be incorporated into this Poller timers must not be null.

Add the given socket and Action to this Poller's collection of socket/actions.

the Socket to add the Action to add socket and callback must not be null. The socket must not have already been added to this poller. This poller must not have already been disposed.

Delete the given socket from this Poller's collection of socket/actions.

the Socket to remove socket must not be null. This poller must not have already been disposed.

Add the given socket to this Poller's list.

the ISocketPollable to add to the list socket must not be null. socket must not have already been added to this poller. This poller must not have already been disposed.

Delete the given socket from this Poller's list.

the ISocketPollable to remove from the list socket must not be null. This poller must not have already been disposed.

Delete all sockets from this Poller's list.

This poller must not have already been disposed.

Add the given timer to this Poller's list.

the NetMQTimer to add to the list timer must not be null. This poller must not have already been disposed.

Delete the given timer from this Poller's list.

the NetMQTimer to remove from the list timer must not be null. This poller must not have already been disposed.

Remove all timers from this Poller's list.

This poller must not have already been disposed.

Cancel the poller job when PollTillCancelled is called

Cancel the poller job when PollTillCancelled is called and wait for the PollTillCancelled to complete

Poll one time.

Poll till Cancel or CancelAndJoin is called. This is a blocking method.

The non blocking version of PollTillCancelled, starting the PollTillCancelled on new thread. Will poll till Cancel or CancelAndJoin is called. This method is not blocking.

Poll till Cancel or CancelAndJoin is called. This is a blocking method.

Stop the poller job. It may take a while until the poller is fully stopped. If it doesn't stop within 20 seconds, it times-out anyway and returns.

if true, this method will block until the poller is fully stopped

Stop the poller job. This returns after waiting for that thread to stop. This is equivalent to calling CancelAndJoin.

Handle the EventsChanged event of any of the sockets contained within this Poller, by marking this poller as "dirty" in order to reset the poll events.

the object that was the source of the event the NetMQSocketEventArgs associated with the event

Return the soonest timeout value of all the timers in the list, or zero to indicate any of them have already elapsed. The timeout is in milliseconds from now.

the number of milliseconds before the first timer expires, or zero if one already has

Poll as long as the given Func evaluates to true.

a Func that returns a boolean value, to evaluate on each poll-iteration to decide when to exit the loop This poller must not have already been disposed. This poller must not have already been started.

Signal this poller to stop, and return immediately if waitForCloseToComplete is false, block until the poller has actually stopped if waitForCloseToComplete is true.

block until the poller has actually stopped if this poller has already been disposed if this poller has not been started

Gets whether has been added to this .

Perform any freeing, releasing or resetting of contained resources. If this poller is already started, signal the polling thread to stop - and block to wait for it.

Calling this again after the first time, does nothing.

Perform any freeing, releasing or resetting of contained resources. If this poller is already started, signal the polling thread to stop - and block to wait for it.

true if releasing managed resources

Get whether the polling has started. This is set true at the beginning of the Start method, and cleared in the Stop method.

Get or set the poll timeout in milliseconds.

This flags enum-type is simply an indication of the direction of the poll-event, and can be None, PollIn, PollOut, or PollError.

Extension methods for the enum.

Test whether has the flag set.

Forwards messages bidirectionally between two sockets. You can also specify a control socket tn which proxied messages will be sent.

This class must be explicitly started by calling . If an external has been specified, then that call will block until is called. If using an external , ensure the front and back end sockets have been added to it. Users of this class must call when messages should no longer be proxied.

Create a new instance of a Proxy (NetMQ.Proxy) with the given sockets to serve as a front-end, a back-end, and a control socket.

the socket that messages will be forwarded from the socket that messages will be forwarded to this socket will have incoming messages also sent to it - you can set this to null if not needed this socket will have outgoing messages also sent to it - you can set this to null if not needed an optional external poller to use within this proxy

Create a new instance of a Proxy (NetMQ.Proxy) with the given sockets to serve as a front-end, a back-end, and a control socket.

the socket that messages will be forwarded from the socket that messages will be forwarded to this socket will have messages also sent to it - you can set this to null if not needed an optional external poller to use within this proxy is not null and either or are not contained within it.

Start proxying messages between the front and back ends. Blocks, unless using an external .

The proxy has already been started.

Stops the proxy, blocking until the underlying has completed.

The proxy has not been started.

Provides extension methods for the interface, via which messages may be received in several ways.

The used in string related methods that do not explicitly provide an encoding parameter.

Indicates an infinite timeout for receive operations.

Block until the next message arrives, then make the message's data available via .

The call blocks until the next message arrives, and cannot be interrupted. This a convenient and safe when you know a message is available, such as for code within a callback. The socket to receive from. An object to receive the message's data into.

Receive a single frame from , blocking until one arrives.

The socket to receive from. The content of the received message frame.

Receive a single frame from , blocking until one arrives. Indicate whether further frames exist via .

The socket to receive from. true if another frame of the same message follows, otherwise false. The content of the received message frame.

Attempt to receive a single frame from . If no message is immediately available, return false.

The socket to receive from. The content of the received message frame, or null if no message was available. true if a message was available, otherwise false.

Attempt to receive a single frame from . If no message is immediately available, return false. Indicate whether further frames exist via .

The socket to receive from. true if another frame of the same message follows, otherwise false. The content of the received message frame, or null if no message was available. true if a message was available, otherwise false.

Attempt to receive a single frame from . If no message is available within , return false.

The socket to receive from. The maximum period of time to wait for a message to become available. The content of the received message frame, or null if no message was available. true if a message was available, otherwise false.

Attempt to receive a single frame from . If no message is available within , return false. Indicate whether further frames exist via .

The socket to receive from. true if another frame of the same message follows, otherwise false. The maximum period of time to wait for a message to become available. The content of the received message frame, or null if no message was available. true if a message was available, otherwise false.

get the data section of the available message as byte[]

The socket to receive from. The message's data as a newly allocated array of bytes. If is a and elapsed.

get the data section of the available message as byte[]

The socket to receive from. true when more parts of a multipart message are available The message's data as a newly allocated array of bytes. If is a and elapsed.

potentially non-blocking get the data section of the available message as byte[]

The socket to receive from. Non-blocking if true, otherwise blocking. true when more parts of a multipart message are available. The message's data as a newly allocated array of bytes. If is a and elapsed.

get the data section of the available message as byte[]

The socket to receive from. a SendReceiveOptions that can specify the DontWait or SendMore flags The message's data as a newly allocated array of bytes. If is a and elapsed.

get the data section of the available message as byte[]

The socket to receive from. a SendReceiveOptions which can specify the DontWait or SendMore flags (or None) true when more parts of a multipart message are available The message's data as a newly allocated array of bytes. No message was available within the allowed timeout period. Try again.

Receive the next message's data as a , or return null if no message arrives within .

The socket to receive from. The length of time wait for an inbound message. The received message bytes, or null if no message arrived within . The internal select operation failed. has been stopped.

Receive all frames of the next message from , blocking until a message arrives.

The socket to receive from. Optional initial for the returned . All frames of a multipart message as a list having one or more items.

Receive all frames of the next message from , blocking until a message arrives.

The socket to receive from. Reference to a list for return values. If null a new instance will be assigned, otherwise the provided list will be cleared and populated. Optional initial for the returned .

Attempt to receive all frames of the next message from . If no message is immediately available, return false.

Attempt to receive all frames of the next message from . If no message is available within , return false.

The socket to receive from. The maximum period of time to wait for a message to become available. Reference to a list for return values. If null a new instance will be assigned, otherwise the provided list will be cleared and populated. Optional initial for the returned .

Receives a list of all frames of the next message, each as an array of bytes.

The socket to receive from. Specifies the initial capacity of the used to buffer results. If the number of frames is known, set it here. If more frames arrive than expected, an extra allocation will occur, but the result will still be correct. A list of all frames of the next message, each as an array of bytes. If is a and elapsed.

Receives a list of all frames of the next message, each as an array of bytes.

Receive a single frame from , blocking until one arrives, and decode as a string using .

The socket to receive from. The content of the received message frame as a string.

Receive a single frame from , blocking until one arrives, and decode as a string using . Indicate whether further frames exist via .

The socket to receive from. true if another frame of the same message follows, otherwise false. The content of the received message frame.

Receive a single frame from , blocking until one arrives, and decode as a string using .

The socket to receive from. The encoding used to convert the frame's data to a string. The content of the received message frame as a string.

Receive a single frame from , blocking until one arrives, and decode as a string using . Indicate whether further frames exist via .

The socket to receive from. The encoding used to convert the frame's data to a string. true if another frame of the same message follows, otherwise false. The content of the received message frame as a string.

Attempt to receive a single frame from , and decode as a string using . If no message is immediately available, return false.

The socket to receive from. The content of the received message frame as a string, or null if no message was available. true if a message was available, otherwise false.

Attempt to receive a single frame from , and decode as a string using . If no message is immediately available, return false.

The socket to receive from. The content of the received message frame as a string, or null if no message was available. true if another frame of the same message follows, otherwise false. true if a message was available, otherwise false.

Attempt to receive a single frame from , and decode as a string using . If no message is immediately available, return false.

The socket to receive from. The encoding used to convert the frame's data to a string. The content of the received message frame as a string, or null if no message was available. true if a message was available, otherwise false.

Attempt to receive a single frame from , and decode as a string using . If no message is immediately available, return false.

Attempt to receive a single frame from , and decode as a string using . If no message is available within , return false.

The socket to receive from. The maximum period of time to wait for a message to become available. The content of the received message frame as a string, or null if no message was available. true if a message was available, otherwise false.

Attempt to receive a single frame from , and decode as a string using . If no message is available within , return false.

The socket to receive from. The maximum period of time to wait for a message to become available. The encoding used to convert the frame's data to a string. The content of the received message frame as a string, or null if no message was available. true if a message was available, otherwise false.

Attempt to receive a single frame from , and decode as a string using . If no message is available within , return false.

Read an available message, extract the data which is converted to a string using , and inform of the availability of more messages via .

The socket to receive from. the Encoding to use a SendReceiveOptions value that can specify the DontWait or SendMore flags true if more messages are available, false otherwise the message data encoded as a string encoding must not be null. No message was available within the allowed timeout period. Try again.

Read an available message, extract the data which is converted to a string using , and inform of the availability of more messages via .

The socket to receive from. a SendReceiveOptions value that can specify the DontWait or SendMore flags true if more messages are available, false otherwise the message data encoded as a string - using the ASCII-encoding If is a and elapsed.

Read an available message, and extract the data which is converted to a string using .

The socket to receive from. a SendReceiveOptions value that can specify the DontWait or SendMore flags the message data encoded a a string using the ASCII-encoding If is a and elapsed.

reads an available message and extracts the data which is converted to a string using .

The socket to receive from. the encoding to use a SendReceiveOptions value that can specify the DontWait or SendMore flags the message data encoded as a string If is a and elapsed.

non-blocking reads an available message and extracts the data which is converted to a string using as encoding and informs about the availability of more messages via .

The socket to receive from. if true the method is non-blocking true if more messages are available, false otherwise the ASCII string representation of the data of the message If is a and elapsed.

non-blocking reads an available message and extracts the data which is converted to a string using and informs about the availability of more messages via .

The socket to receive from. the encoding to use for the string representation if true the method is non-blocking true if more messages are available, false otherwise the ASCII string representation of the data of the message If is a and elapsed.

reads an available message and extracts the data which is converted to a string using as encoding and informs about the availability of more messages via .

The socket to receive from. true if more messages are available, false otherwise the ASCII string representation of the data of the message If is a and elapsed.

reads an available message and extracts the data which is converted to a string using and informs about the availability of more messages via .

The socket to receive from. the encoding to use for the string representation true if more messages are available, false otherwise the string representation of the encoded data of the message If is a and elapsed.

reads an available message and extracts the data which is converted to a string using .

The socket to receive from. the encoding to use for the string representation the string representation of the encoded data of the message If is a and elapsed.

reads an available message and extracts the data which is converted to a string using .

The socket to receive from. the ASCII string representation of the data of the message If is a and elapsed.

Receive a message if available within .

The socket to receive from. the time span to wait for a message to receive The string representation of the data of the message or null if no message arrives within . If is a and elapsed. The internal select operation failed. The socket has been stopped.

Receive a message if available within .

The socket to receive from. the encoding to use for the string representation the time span to wait for a message to receive The string representation of the encoded data of the message or null if no message arrived within . If is a and elapsed. The internal select operation failed. The socket has been stopped.

Receive all frames of the next message from , blocking until they arrive, and decode as strings using .

The socket to receive from. Specifies the initial capacity of the used to buffer results. If the number of frames is known, set it here. If more frames arrive than expected, an extra allocation will occur, but the result will still be correct. The content of the received message frame as a string.

Receive all frames of the next message from , blocking until they arrive, and decode as strings using .

The socket to receive from. The encoding used to convert the frame's data to a string. Specifies the initial capacity of the used to buffer results. If the number of frames is known, set it here. If more frames arrive than expected, an extra allocation will occur, but the result will still be correct.

Attempt to receive all frames of the next message from , and decode them as strings using . If no message is immediately available, return false.

The socket to receive from. The frames of the received message as strings. Untouched if no message was available. Specifies the initial capacity of the used to buffer results. If the number of frames is known, set it here. If more frames arrive than expected, an extra allocation will occur, but the result will still be correct. true if a message was available, otherwise false.

Attempt to receive all frames of the next message from , and decode them as strings using . If no message is immediately available, return false.

The socket to receive from. The encoding used to convert the frame's data to a string. The frames of the received message as strings. Untouched if no message was available. Specifies the initial capacity of the used to buffer results. If the number of frames is known, set it here. If more frames arrive than expected, an extra allocation will occur, but the result will still be correct. true if a message was available, otherwise false.

Attempt to receive all frames of the next message from , and decode them as strings using . If no message is available within , return false.

The socket to receive from. The maximum period of time to wait for a message to become available. The frames of the received message as strings. Untouched if no message was available. Specifies the initial capacity of the used to buffer results. If the number of frames is known, set it here. If more frames arrive than expected, an extra allocation will occur, but the result will still be correct. true if a message was available, otherwise false.

Attempt to receive all frames of the next message from , and decode them as strings using . If no message is available within , return false.

The socket to receive from. The maximum period of time to wait for a message to become available. The encoding used to convert the frame's data to a string. The frames of the received message as strings. Untouched if no message was available. Specifies the initial capacity of the used to buffer results. If the number of frames is known, set it here. If more frames arrive than expected, an extra allocation will occur, but the result will still be correct. true if a message was available, otherwise false.

Receives a list of all frames of the next message, decoded as ASCII strings.

Receives a list of all frames of the next message, decoded as strings having the specified .

Blocks until a message is received. The list may have one or more entries. The socket to receive from. The encoding to use when converting a frame's bytes into a string. Specifies the initial capacity of the used to buffer results. If the number of frames is known, set it here. If more frames arrive than expected, an extra allocation will occur, but the result will still be correct. A list of all frames of the next message, decoded as strings. If is a and elapsed.

The socket to receive from. If is a and elapsed.

Receive all frames of the next message from , blocking until they arrive.

The socket to receive from. Specifies the initial capacity of the used to buffer results. If the number of frames is known, set it here. If more frames arrive than expected, an extra allocation will occur, but the result will still be correct. The content of the received message frame as a string.

Attempt to receive all frames of the next message from . If no message is immediately available, return false.

The socket to receive from. The received message. Untouched if no message was available. Specifies the initial capacity of the used to buffer results. If the number of frames is known, set it here. If more frames arrive than expected, an extra allocation will occur, but the result will still be correct. true if a message was available, otherwise false.

Attempt to receive all frames of the next message from . If no message is available within , return false.

The socket to receive from. The maximum period of time to wait for a message to become available. The received message. Untouched if no message was available. Specifies the initial capacity of the used to buffer results. If the number of frames is known, set it here. If more frames arrive than expected, an extra allocation will occur, but the result will still be correct. true if a message was available, otherwise false.

non-blocking receive of a (multipart)message and stores it in the object

The socket to receive from. the NetMQMessage to receive the bytes into non-blocking if true and blocking otherwise If is a and elapsed.

non-blocking receive of a (multipart)message

The socket to receive from. non-blocking if true and blocking otherwise the received message If is a and elapsed.

receive of a (multipart)message within a specified timespan

The socket to receive from. the timespan to wait for a message the received message or null if non arrived within the timeout period The socket has been stopped. The internal select operation failed. If is a and elapsed.

Receive frames from , blocking until a valid signal arrives.

The socket to receive from. true if the received signal was zero, otherwise false.

Attempt to receive a valid signal from . If no message is immediately available, return false.

The socket to receive from. true if the received signal was zero, otherwise false. If no signal received, false. true if a valid signal was observed, otherwise false.

Attempt to receive a valid signal from . If no message is available within , return false.

The socket to receive from. The maximum period of time to wait for a message to become available. true if the received signal was zero, otherwise false. If no signal received, false. true if a valid signal was observed, otherwise false.

Receives repeatedly until a valid signal message is seen, then returns the signal value.

Signal messages must contain a single frame or eight bytes, where the first eight bytes (excluding the first bit) must equal exactly 0x77665544332211. The socket to receive from. true if that one frame has no bits set other than in the lowest-order byte. If is a and elapsed.

Receive a single frame from , blocking until one arrives, then ignore its content.

The socket to receive from.

Receive a single frame from , blocking until one arrives, then ignore its content. Indicate whether further frames exist via .

The socket to receive from. true if another frame of the same message follows, otherwise false.

Attempt to receive a single frame from , then ignore its content. If no message is immediately available, return false.

The socket to receive from. true if a frame was received and ignored, otherwise false.

Attempt to receive a single frame from , then ignore its content. If no message is immediately available, return false. Indicate whether further frames exist via .

The socket to receive from. true if another frame of the same message follows, otherwise false. true if a frame was received and ignored, otherwise false.

Attempt to receive a single frame from , then ignore its content. If no message is available within , return false.

The socket to receive from. The maximum period of time to wait for a message to become available. true if a frame was received and ignored, otherwise false.

Attempt to receive a single frame from , then ignore its content. If no message is available within , return false. Indicate whether further frames exist via .

The socket to receive from. The maximum period of time to wait for a message to become available. true if another frame of the same message follows, otherwise false. true if a frame was received and ignored, otherwise false.

Receive all frames of the next message from , blocking until a message arrives, then ignore their contents.

The socket to receive from.

Attempt to receive all frames of the next message from , then ignore their contents. If no message is immediately available, return false.

The socket to receive from. true if a frame was received and ignored, otherwise false.

Attempt to receive all frames of the next message from , then ignore their contents. If no message is available within , return false.

The socket to receive from. The maximum period of time to wait for a message to become available. true if a frame was received and ignored, otherwise false.

The used in string related methods that do not explicitly provide an encoding parameter.

Indicates an infinite timeout for send and receive operations.

This flags enum-type provides a way to specify basic Receive behaviour. It may be None, or have the DontWait bit (indicating to wait for a message), or the SendMore bit, set.

Both bits cleared (neither DontWait nor SendMore are set)

Set this flag to specify NOT to block waiting for a message to arrive.

Set this (the SendMore bit) to signal more messages beyond the current one, for a given unit of communication.

This enum-type specifies socket transport events (TCP and IPC only).

A SocketOptions is simply a convenient way to access the options of a particular socket. This class holds a reference to the socket, and it's properties provide a concise way to access that socket's option values -- instead of calling GetSocketOption/SetSocketOption.

The NetMQSocket that this SocketOptions is referencing.

Create a new SocketOptions that references the given NetMQSocket.

the NetMQSocket for this SocketOptions to hold a reference to

Get or set the I/O-thread affinity. This is a 64-bit value used to specify which threads from the I/O thread-pool associated with the socket's context shall handle newly-created connections. 0 means no affinity, meaning that work shall be distributed fairly among all I/O threads. For non-zero values, the lowest bit corresponds to thread 1, second lowest bit to thread 2, and so on.

Unused.

Get or set unique identity of the socket, from a message-queueing router's perspective. This is a byte-array of at most 255 bytes.

Get or set the maximum send or receive data rate for multicast transports on the specified socket.

Get or set the recovery-interval for multicast transports using the specified socket. This option determines the maximum time that a receiver can be absent from a multicast group before unrecoverable data loss will occur. Default is 10,000 ms (10 seconds).

Get or set the size of the transmit buffer for the specified socket.

Get or set the size of the receive buffer for the specified socket. A value of zero means that the OS default is in effect.

Gets whether the last frame received on the socket had the more flag set or not.

true if receive more; otherwise, false.

Get or set the linger period for the specified socket, which determines how long pending messages which have yet to be sent to a peer shall linger in memory after a socket is closed.

If socket created with Context default is -1 if socket createw without socket (using new keyword) default is zero. If context is used this also affects the termination of context, otherwise this affects the exit of the process. -1: Specifies an infinite linger period. Pending messages shall not be discarded after the socket is closed; attempting to terminate the socket's context shall block until all pending messages have been sent to a peer. 0: Specifies no linger period. Pending messages shall be discarded immediately when the socket is closed. Positive values specify an upper bound for the linger period. Pending messages shall not be discarded after the socket is closed; attempting to terminate the socket's context shall block until either all pending messages have been sent to a peer, or the linger period expires, after which any pending messages shall be discarded.

Get or set the initial reconnection interval for the specified socket. This is the period to wait between attempts to reconnect disconnected peers when using connection-oriented transports. The default is 100 ms. -1 means no reconnection.

With ZeroMQ, the reconnection interval may be randomized to prevent reconnection storms in topologies with a large number of peers per socket.

Get or set the maximum reconnection interval for the specified socket. This is the maximum period to shall wait between attempts to reconnect. On each reconnect attempt, the previous interval shall be doubled until this maximum period is reached. The default value of zero means no exponential backoff is performed.

This is the maximum period NetMQ shall wait between attempts to reconnect. On each reconnect attempt, the previous interval shall be doubled until this maximum period is reached. This allows for an exponential backoff strategy. The default value of zero means no exponential backoff is performed and reconnect interval calculations are only based on ReconnectIvl.

Get or set the maximum length of the queue of outstanding peer connections for the specified socket. This only applies to connection-oriented transports. Default is 100.

Get or set the upper limit to to the size for inbound messages. If a peer sends a message larger than this it is disconnected. The default value is -1, which means no limit.

Get or set the high-water-mark for transmission. This is a hard limit on the number of messages that are allowed to queue up before mitigative action is taken. The default is 1000.

Get or set the high-water-mark for reception. This is a hard limit on the number of messages that are allowed to queue up before mitigative action is taken. The default is 1000.

Get or set the time-to-live (maximum number of hops) that outbound multicast packets are allowed to propagate. The default value of 1 means that the multicast packets don't leave the local network.

Get or set the amount of time after which a synchronous receive call will time out.

Specifies the amount of time after which a synchronous send call will time out. A value of 0 means Send will return immediately, with a EAGAIN error if the message cannot be sent. A value of -1 means to block until the message is sent. TODO: May need to update this explanation.

Get or set whether the underlying socket is for IPv4 only (not IPv6), as opposed to one that allows connections with either IPv4 or IPv6.

Get the last endpoint bound for TCP and IPC transports. The returned value will be a string in the form of a ZMQ DSN.

If the TCP host is ANY, indicated by a *, then the returned address will be 0.0.0.0 (for IPv4).

Get or set whether to use TCP keepalive.

When Keepalive is enabled, then your socket will periodically send an empty keepalive probe packet with the ACK flag on. The remote endpoint does not need to support keepalive at all, just TCP/IP. If you receive a reply to your keepalive probe, you can assume that the connection is still up and running. This procedure is useful because if the other peers lose their connection (for example, by rebooting) you will notice that the connection is broken, even if you don't have traffic on it. If the keepalive probes are not replied to by your peer, you can assert that the connection cannot be considered valid and then take the corrective action.

Unused

Get or set the keep-alive time - the duration between two keepalive transmissions in idle condition. The TCP keepalive period is required by socket implementers to be configurable and by default is set to no less than 2 hours.

Get or set the TCP keep-alive interval - the duration between two keepalive transmission if no response was received to a previous keepalive probe.

By default a keepalive packet is sent every 2 hours or 7,200,000 milliseconds (TODO: Check these comments concerning default values! jh) if no other data have been carried over the TCP connection. If there is no response to a keepalive, it is repeated once every KeepAliveInterval seconds. The default is one second.

Get or set the attach-on-connect value. If set to true, this will delay the attachment of a pipe on connect until the underlying connection has completed. This will cause the socket to block if there are no other connections, but will prevent queues from filling on pipes awaiting connection. Default is false.

This applies only to publisher sockets. Set whether to send all subscription messages upstream, not just unique ones. The default is false.

This applies only to publisher sockets. Set whether to support broadcast functionality

When enabled new router connections with same identity take over old ones

Get or set the byte-order: big-endian, vs little-endian.

A DealerSocket is a NetMQSocket, whereby the dealer sends messages in a way intended to achieve load-balancing - which are received in a fair queueing manner.

Create a new DealerSocket and attach socket to zero or more endpoints.

List of NetMQ endpoints, seperated by commas and prefixed by '@' (to bind the socket) or '>' (to connect the socket). Default action is connect (if endpoint doesn't start with '@' or '>') var socket = new DealerSocket(">tcp://127.0.0.1:5555,@127.0.0.1:55556");

Create a new DealerSocket based upon the given SocketBase.

the SocketBase to create the new socket from

A PairSocket is a NetMQSocket, usually used to synchronize two threads - using only one socket on each side.

Create a new PairSocket and attach socket to zero or more endpoints.

List of NetMQ endpoints, seperated by commas and prefixed by '@' (to bind the socket) or '>' (to connect the socket). Default action is connect (if endpoint doesn't start with '@' or '>') var socket = new PairSocket(">tcp://127.0.0.1:5555,@127.0.0.1:55556");

Create a new PairSocket based upon the given SocketBase.

the SocketBase to create the new socket from

A PublisherSocket is a NetMQSocket intended to be used as the Pub in the PubSub pattern. The intended usage is for publishing messages to all subscribers which are subscribed to a given topic.

Create a new PublisherSocket and attach socket to zero or more endpoints.

List of NetMQ endpoints, seperated by commas and prefixed by '@' (to bind the socket) or '>' (to connect the socket). Default action is bind (if endpoint doesn't start with '@' or '>') var socket = new PublisherSocket(">tcp://127.0.0.1:5555,>127.0.0.1:55556");

Create a new PublisherSocket based upon the given SocketBase.

the SocketBase to create the new socket from

doesn't support sending, so this override throws .

Receive is not supported.

doesn't support sending, so this override throws .

Receive is not supported.

A PullSocket is a NetMQSocket intended to be used as the "Pull" part of the Push-Pull pattern. This will "pull" messages that have been pushed from the "push" socket.

Create a new PullSocket and attach socket to zero or more endpoints.

List of NetMQ endpoints, seperated by commas and prefixed by '@' (to bind the socket) or '>' (to connect the socket). Default action is bind (if endpoint doesn't start with '@' or '>') var socket = new PullSocket(">tcp://127.0.0.1:5555,>127.0.0.1:55556");

Create a new PullSocket based upon the given SocketBase.

the SocketBase to create the new socket from

Don't invoke this on a PullSocket - you'll just get a NotSupportedException.

the Msg to transmit a SendReceiveOptions that may be None, or any of the bits DontWait, SendMore Send must not be called on a PullSocket.

A PushSocket is a NetMQSocket intended to be used as the "Push" part of the Push-Pull pattern. This will "push" messages to be pulled by the "pull" socket.

Create a new PushSocket and attach socket to zero or more endpoints.

List of NetMQ endpoints, seperated by commas and prefixed by '@' (to bind the socket) or '>' (to connect the socket). Default action is connect (if endpoint doesn't start with '@' or '>') var socket = new PushSocket(">tcp://127.0.0.1:5555,@127.0.0.1:55556");

Create a new PushSocket based upon the given SocketBase.

the SocketBase to create the new socket from

doesn't support sending, so this override throws .

Receive is not supported.

doesn't support sending, so this override throws .

Receive is not supported.

A RequestSocket is a NetMQSocket intended to be used as the Request part of the Request-Response pattern. This is generally paired with a ResponseSocket.

Create a new RequestSocket and attach socket to zero or more endpoints.

List of NetMQ endpoints, seperated by commas and prefixed by '@' (to bind the socket) or '>' (to connect the socket). Default action is connect (if endpoint doesn't start with '@' or '>') var socket = new RequestSocket(">tcp://127.0.0.1:5555,@127.0.0.1:55556");

Create a new RequestSocket based upon the given SocketBase.

the SocketBase to create the new socket from

Try to send request message and return the response as a message, or return null if not successful

a string denoting the address to connect to The request message The number of times to try The timeout for each request Report topics: Failure, Retry, Send, Success the response message, or null if not successful

Try to send request string and return the response string, or return null if not successful

a string denoting the address to connect to The request string The number of times to try The timeout for each request Report topics: Failure, Retry, Send, Success the response message, or null if not successful

A ResponseSocket is a NetMQSocket intended to be used as the Response part of the Request-Response pattern. This is generally paired with a RequestSocket.

Create a new ResponseSocket and attach socket to zero or more endpoints.

List of NetMQ endpoints, seperated by commas and prefixed by '@' (to bind the socket) or '>' (to connect the socket). Default action is bind (if endpoint doesn't start with '@' or '>') var socket = new ResponseSocket(">tcp://127.0.0.1:5555,>127.0.0.1:55556");

Create a new ResponseSocket based upon the given SocketBase.

the SocketBase to create the new socket from

Router socket, the first message is always the identity of the sender

Create a new RouterSocket and attach socket to zero or more endpoints.

List of NetMQ endpoints, seperated by commas and prefixed by '@' (to bind the socket) or '>' (to connect the socket). Default action is bind (if endpoint doesn't start with '@' or '>') var socket = new RouterSocket(">tcp://127.0.0.1:5555,>127.0.0.1:55556");

Create a new RouterSocket based upon the given SocketBase.

the SocketBase to create the new socket from

This is a NetMQSocket but provides no additional functionality. You can use it when you need an instance that is a NetMQSocket but with none of the distinguishing behavior of any of the other socket types.

This is provided because NetMQSocket is an abstract class, so you cannot instantiate it directly.

Create a new StreamSocket and attach socket to zero or more endpoints.

List of NetMQ endpoints, seperated by commas and prefixed by '@' (to bind the socket) or '>' (to connect the socket). Default action is connect (if endpoint doesn't start with '@' or '>') var socket = new StreamSocket(">tcp://127.0.0.1:5555,@127.0.0.1:55556");

Create a new StreamSocket based upon the given SocketBase.

the SocketBase to create the new socket from

A SubscriberSocket is a NetMQSocket intended to be used as the "Sub" in the PubSub pattern. The intended usage is to receive messages from the publisher socket.

Create a new SubscriberSocket and attach socket to zero or more endpoints.

List of NetMQ endpoints, seperated by commas and prefixed by '@' (to bind the socket) or '>' (to connect the socket). Default action is connect (if endpoint doesn't start with '@' or '>') var socket = new SubscriberSocket(">tcp://127.0.0.1:5555,@127.0.0.1:55556");

Create a new SubscriberSocket based upon the given SocketBase.

the SocketBase to create the new socket from

Don't invoke this on a SubscriberSocket - you'll just get a NotSupportedException.

the Msg to transmit a SendReceiveOptions that may be None, or any of the bits DontWait, SendMore Send must not be called on a SubscriberSocket.

Subscribe this socket to the given 'topic' - which means enable this socket to receive messages that begin with this string prefix. You can set topic to an empty string to subscribe to everything.

this specifies what text-prefix to subscribe to, or may be an empty-string to specify ALL

Subscribe this socket to the given 'topic' - which means enable this socket to receive messages that begin with this string prefix, using the given Encoding. You can set topic to an empty string to subscribe to everything.

this specifies what text-prefix to subscribe to, or may be an empty-string to specify ALL the character-Encoding to use when converting the topic string internally into a byte-array

Subscribe this socket to the given 'topic' - which means enable this socket to receive messages that begin with this array of bytes.

this specifies what byte-array prefix to subscribe to

Subscribe this socket to all topics - which means enable this socket to receive all messages regardless of what the string prefix is. This is the same as calling Subscribe with an empty-string for the topic.

Remove this socket's subscription to the given topic.

a string denoting which the topic to stop receiving

Remove this socket's subscription to the given topic.

a string denoting which the topic to stop receiving the Encoding to use when converting the topic string internally into a byte-array

Remove this socket's subscription to the given topic.

a byte-array denoting which the topic to stop receiving

An XPublisherSocket is a NetMQSocket intended to be used as the XPub in the XPub/XSub pattern. The intended usage is for serving, together with a matching XSubscriberSocket, as a stable intermediary between a PublisherSocket and it's SubscriberSockets.

Create a new XPublisherSocket and attach socket to zero or more endpoints.

List of NetMQ endpoints, seperated by commas and prefixed by '@' (to bind the socket) or '>' (to connect the socket). Default action is bind (if endpoint doesn't start with '@' or '>') var socket = new XPublisherSocket(">tcp://127.0.0.1:5555,>127.0.0.1:55556");

Create a new XPublisherSocket based upon the given .

the SocketBase to create the new socket from

In case of socket set to manual mode will subscribe the last subscriber to the topic

a string specifying the Topic to subscribe to

In case of socket set to manual mode will subscribe the last subscriber to the topic

a string specifying the Topic to subscribe to the character-Encoding to use when converting the topic string internally into a byte-array

In case of socket set to manual mode will subscribe the last subscriber to the topic

a byte-array specifying the Topic to subscribe to

In case of socket set to manual mode will unsubscribe the last subscriber from a topic

a string specifying the Topic to unsubscribe from

In case of socket set to manual mode will unsubscribe the last subscriber from a topic

a string specifying the Topic to unsubscribe from the character-Encoding to use when converting the topic string internally into a byte-array

In case of socket set to manual mode will unsubscribe the last subscriber from a topic

a byte-array specifying the Topic to unsubscribe from

Publisher sockets generally send a welcome-message to subscribers to give an indication that they have successful subscribed. This method clears that message, such that none is sent.

Publisher sockets send a welcome-message to subscribers to give an indication that they have successful subscribed. This method is how you set the text of that welcome-message.

a string denoting the new value for the welcome-message the character-Encoding to use when converting the topic string internally into a byte-array

Publisher sockets send a welcome-message to subscribers to give an indication that they have successful subscribed. This method is how you set the text of that welcome-message. The Encoding is assumed to be ASCII.

a string denoting the new value for the welcome-message

a byte-array denoting the new value for the welcome-message

An XSubscriberSocket is a NetMQSocket intended to be used as the XSub in the XPub/XSub pattern. The intended usage is for serving, together with a matching XPublisherSocket, as a stable intermediary between a PublisherSocket and it's SubscriberSockets.

Create a new XSubscriberSocket and attach socket to zero or more endpoints.

List of NetMQ endpoints, seperated by commas and prefixed by '@' (to bind the socket) or '>' (to connect the socket). Default action is connect (if endpoint doesn't start with '@' or '>') var socket = new XSubscriberSocket(">tcp://127.0.0.1:5555,@127.0.0.1:55556");

Create a new XSubscriberSocket based upon the given SocketBase.

the SocketBase to create the new socket from

Subscribe this socket to the given 'topic' - which means enable this socket to receive messages that begin with this string prefix. You can set topic to an empty string to subscribe to everything.

this specifies what text-prefix to subscribe to, or may be an empty-string to specify ALL

this specifies what text-prefix to subscribe to, or may be an empty-string to specify ALL the Encoding to use when converting the topic string internally into a byte-array

Subscribe this socket to the given 'topic' - which means enable this socket to receive messages that begin with this array of bytes.

this specifies what byte-array prefix to subscribe to

Remove this socket's subscription to the given topic.

a string denoting which the topic to stop receiving

Remove this socket's subscription to the given topic.

a string denoting which the topic to stop receiving the Encoding to use when converting the topic string internally into a byte-array

Remove this socket's subscription to the given topic.

a byte-array denoting which the topic to stop receiving

All public types have been moved out of the namespace. This class remains to prevent compile errors when users still have using NetMQ.zmq; in their code.

This enum-type is used to specify the basic type of message-queue socket based upon the intended pattern, such as Pub,Sub, Req,Rep, Dealer,Router, Pull,Push, Xpub,Xsub.

No socket-type is specified

This denotes a Pair socket (usually paired with another Pair socket).

This denotes a Publisher socket (usually paired with a Subscriber socket).

This denotes a Subscriber socket (usually paired with a Publisher socket).

This denotes a Request socket (usually paired with a Response socket).

This denotes a Response socket (usually paired with a Request socket).

This denotes an Dealer socket.

This denotes an Router socket.

This denotes a Pull socket (usually paired with a PUsh socket).

This denotes a Push socket (usually paired with a Pull socket).

This denotes an XPublisher socket.

This denotes an XSubscriber socket.

This denotes a Stream socket - which is a parent-class to the other socket types.

Static class used to convert enumeration values to custom strings. This class is necessary because there is no mechanism to override the ToString() method for enumerations.

To get the customized string for an enumeration value, a program must call the static method EnumFormat.ToString(value) and not value.ToString().

Gets the display text for an enumeration value.

A string is searched for in three places, in this order: A custom string specified by SetCustomString(). A string resource in the resource file (enum namespace).Enumerations named (type name).(enum name). From the DisplayTextAttribute for the enumeration value. If no value is found, the standard string representation of the enumeration is returned. The enumeration value for which to obtain the text string. The string for the enumeration value.

Sets a custom string for an enumeration value. This will override any string set with a DisplayTextAttribute.

The enumeration value for which to set the custom text string. The custom text string for this enumeration value.

Enum of configurable buttons. More than one button can be shown by OR'ing the values. The 'Close' button is not configurable.

Shows no buttons other than the "Close" button.

Shows a button with the text - 'End User Agreement'.

Shows a button with the text - 'Licence'.

Shows a button with the text - 'Version Info'.

Enum of background types for use on the About dialog box.

Sets the default Xcalibur 1.0 image that is part of the current assembly.

Sets the default Foundation 1.0 image that is part of the current assembly.

Set this option if a custom image needs to be set. Using this option

Use this if no backgroud image is to be shown.

This form is used to show the about dialog box with customised information and it can be reused across the applications.Certain elements of this dialog are configurable. Callers can customize 3 buttons by using the AboutDialogButtons enum. By default only the Close button is shown. This button cannot be configured. If other buttons are enabled, callers need to subscribe to ButtonClicked event.

Overloaded constructor, the 3 parameters are manadatory by this class.

Background image to use Application Name Flags from AboutDialogButtons to configure custom buttons.

Method to show the buttons on the dialog box

AboutDialogButtons[]

Required designer variable.

Clean up any resources being used.

true if managed resources should be disposed; otherwise, false.

Required method for Designer support - do not modify the contents of this method with the code editor.

Occurs when any of the custom buttons are clicked.

Set a custom image as backgroud to this About Box. This property can be set only if this class is constructed with the AboutDialogBackground.CustomImage. Gets the currently set background for this class.

Text describing the product; in general this gives more information about the application. No description is available by default.

Date when the application was built. No data is set by default. Applications using this class need to set this as it is likely to differ b/w applications.

Sets the version to be shown in the AboutBox. Defaults to "BaseVersion" of 1.0. Callers can overwrite this value if needed.

Describes Patent information. This is to be set by the caller. Defaults to empty string.

Text describing the Copyright information. Callers can override this text.

Given the application name, this returns the dialogs title in the desired format. Typically used by caller to construct custom About Box for applications.

This class instance is used as an argument to the the ButtonClicked event defined in ThermoFisher.Foundation.Utilities.FormAboutBox.

Determines the button clicked.

End User Licence Agreement form.

default constructor to initialize the form .

close the dialog.

object raised for this event. arguments for this event.

Required designer variable.

Clean up any resources being used.

true if managed resources should be disposed; otherwise, false.

Required method for Designer support - do not modify the contents of this method with the code editor.

Extended MessageBoxEx Class to give support to Right reading and also To avoid Fx Cop issues

Show a message box with all necessary information

Parent form reference Text to be displayed message box caption set of butons to be displayed Icon to be shown Default Button Message Box Options DialogResult object

Show a message box with all necessary information

Text to be displayed message box caption set of butons to be displayed Icon to be shown Default Button Message Box Options DialogResult object

This method is used to show information icon

owner of the window message to be displayed caption to be displayed Dialog Results

Shows message box with a Warning Icon

owner of the window message to be displayed caption to be displayed Dialog Results

This shows message box with Error Icon

owner of the window message to be displayed caption to be displayed Dialog Results

Check whether the form is Right To Left reading

owner of this message box TRUE, if the form is RightToLeft else FALSE

PeriodicTableElements is a Static class to check whether a given element is in Periodic table or not.

Determines whether an element is available in supported element list

object True if the Element is present in the Periodic Table periodicTableElementList list

First Determines whether an element is available in supported element list and returns its full Name.

Isotope to Search. Full Name of Isotope.

Returns the number of Elements in the Periodic Table

Gets the Prriodic elements list

Gets the Prriodic element Names List

A strongly-typed resource class, for looking up localized strings, etc.

Returns the cached ResourceManager instance used by this class.

Overrides the current thread's CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to {0} {1} {2}.

Looks up a localized string similar to Warning: This computer program is protected by copyright law and international treaties. Unauthorized reproduction or distribution of this program, or any portion of it, may result in severe civil and criminal penalties, and will be prosecuted to the maximum extent possible under the law..

Looks up a localized resource of type System.Drawing.Bitmap.

Looks up a localized string similar to .

Looks up a localized string similar to About {0} {1}.

Looks up a localized resource of type System.Drawing.Bitmap.

Looks up a localized string similar to 1.0.

Looks up a localized string similar to Thermo.

Looks up a localized resource of type System.Drawing.Bitmap.

Looks up a localized string similar to {\rtf1\adeflang1025\ansi\ansicpg1252\uc1\adeff0\deff0\stshfdbch0\stshfloch0\stshfhich0\stshfbi0\deflang1033\deflangfe1033\themelang1033\themelangfe0\themelangcs0{\fonttbl{\f0\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman{\*\falt Times New Roman};} {\f1\fbidi \fswiss\fcharset0\fprq2{\*\panose 020b0604020202020204}Arial{\*\falt Arial};}{\f2\fbidi \fmodern\fcharset0\fprq1{\*\panose 02070309020205020404}Courier New;}{\f34\fbidi \froman\fcharset0\fprq2{\*\panose 020405030504060302 [rest of string was truncated]";.

Looks up a localized string similar to The About Box is not initialized with a custom image. Please set an image and invoke the dialog..

Looks up a localized resource of type System.Drawing.Bitmap.

Specifies the resource text for an enumeration field. This attribute is used by the EnumFormat class to get display strings for enumeration values.

The resource manager base name provided here will automatically be prefixed with the namespace of the enumeration type. For example, an enumeration defined in XCL.Acquisition with a ResourceText attribute base name of "EnumBase" will use a resource manager base name of "XCL.Acquisition.EnumBase".

Initializes a new instance of the ResourceTextAttribute class with the resource name for the enumeration field. The default resource base name of "Enumerations" is used.

The resource name for the enumeration value.

Initializes a new instance of the ResourceTextAttribute class with the resource name and resource base name for the enumeration field.

The resource name for the enumeration value. The resource manager base name for the enumeration value.

Gets the resource manager base name for the enumeration field.

Gets the resource name for the enumeration field, without the enumeration type's namespace prefix.

This specifies a smoothing envelope shape.

Smooth with equal weights.

Smooth with a gaussian weighting envelope.

This class uses FIR methods, where the tap are calculated based on an envelope shape.

Construct a smoother with a selcetd smooth envelope

Smoothing elvelope shape Length of envelope

Implementation of ICloneable.Clone method. Creates deep copy of this instance.

An exact copy of the current Replicate.

Make a copy of the smoothing object

Object to copy

Set the filter coefficients.

pointer to list of filter values, count: number of filter values.

Set up a equal weighting smoother.

number of filter taps

Set up a Gaussian smoother.

width of filter, must be odd. fraction of Center value at cutoff, e.g. 0.05 for 5%.

Smooth an array of doubles

The data to smooth (unchanged) A new array containing a smoothed copy of data

smooth the supplied data with a repeated moving mean method

the data to smooth The number of points in the smoothing window The number times to smooth

Coordinates the smoothing data into one class, placed into as low level library where many can use it, without recursive dependency.

Creates a new object that is a copy of the current instance.

A new object that is a copy of this instance.

Number of points for smoothing the chromatogram

Number of times to repeat smoothing

Envelope shape used by smoothing algorithm

Provides static methods for validating properties and method parameters.

Checks the unique identifier.

The unique identifier. emptyGuid

Throws an ArgumentNullException exception if toCheck is null.

The object to check.

Throws an InvalidEnumArgumentException exception if value is not a valid value for the enumeration of the specified type.

Enumeration value to check. System.Type of the enumeration.

Throws an ArgumentOutOfRangeException exception if value is less than specified lower bound.

Value to check. Lower bound for check.

Throws an ArgumentOutOfRangeException exception if value is less than specified lower bound.

Value to check. Lower bound for check.

Throws an ArgumentOutOfRangeException exception if value is greater than specified upper bound.

Value to check. Upper bound for check.

Throws an ArgumentOutOfRangeException exception if value is greater than specified upper bound.

Value to check. Upper bound for check.

Throws an ArgumentOutOfRangeException exception if value is less than specified lower bound or greater than specified upper bound.

Value to check. Lower bound for check. Upper bound for check.

Throws an ArgumentOutOfRangeException exception if value is less than specified lower bound or greater than specified upper bound.

Value to check. Lower bound for check. Upper bound for check.

IStorage interface.

Replacement for UCOMIStream (and ComTypes.IStream) interface. More convenient since it uses strongly typed parameters, and ArrayWithOffset class instead of byte[] for Read() and Write().

IEnumSTATSTG interface.

Static class containing Win32 API functions from ole32.dll.

Registry utility static class.

Copy entire registry subkey tree from one location to another.

The source registry key. The subkey of the source key to copy. The destination registry key. The subkey of the destination key for the copy. true to erase the contents of the destination subkey before copying, falseto just overwrite the exiting contents. true if successful, false if not.

Copy entire registry key from one location to another.

The source registry key. The destination registry key. true to erase the contents of the destination subkey before copying, falseto just overwrite the exiting contents. true if successful, false if not.