internal virtual byte[] Receive(byte[] buffer, SocketFlags flags, out int size) { EnsureNotDisposed(); if (buffer == null) { buffer = new byte[0]; } buffer = _socketProxy.Receive(buffer, (int)flags, out size); if (size >= 0) { ReceiveStatus = ReceiveStatus.Received; return(buffer); } if (ErrorProxy.ShouldTryAgain) { ReceiveStatus = ReceiveStatus.TryAgain; return(buffer); } if (ErrorProxy.ContextWasTerminated) { ReceiveStatus = ReceiveStatus.Interrupted; return(buffer); } throw new ZmqSocketException(ErrorProxy.GetLastError()); }
private void SetContextOption(ContextOption option, int value) { if (_contextProxy.SetContextOption((int)option, value) == -1) { throw new ZmqException(ErrorProxy.GetLastError()); } }
internal virtual int Receive(byte[] buffer, SocketFlags flags) { EnsureNotDisposed(); if (buffer == null) { throw new ArgumentNullException("buffer"); } int receivedBytes = _socketProxy.Receive(buffer, (int)flags); if (receivedBytes >= 0) { ReceiveStatus = ReceiveStatus.Received; return(receivedBytes); } if (ErrorProxy.ShouldTryAgain) { ReceiveStatus = ReceiveStatus.TryAgain; return(-1); } if (ErrorProxy.ContextWasTerminated) { ReceiveStatus = ReceiveStatus.Interrupted; return(-1); } throw new ZmqSocketException(ErrorProxy.GetLastError()); }
private static void HandleProxyResult(int result) { // Context termination (ETERM) is an allowable error state, occurring when the // ZmqContext was terminated during a socket method. if (result == -1 && !ErrorProxy.ContextWasTerminated) { throw new ZmqSocketException(ErrorProxy.GetLastError()); } }
private static void ContinueIfInterrupted() { // An error value of EINTR indicates that the operation was interrupted // by delivery of a signal before any events were available. This is a recoverable // error, so try polling again for the remaining amount of time in the timeout. if (!ErrorProxy.ThreadWasInterrupted) { throw new ZmqSocketException(ErrorProxy.GetLastError()); } }
/// <summary> /// Create a <see cref="ZmqContext"/> instance. /// </summary> /// <returns>A <see cref="ZmqContext"/> instance with the default thread pool size (1).</returns> public static ZmqContext Create() { var contextProxy = new ContextProxy(); if (contextProxy.Initialize() == -1) { throw new ZmqException(ErrorProxy.GetLastError()); } return(new ZmqContext(contextProxy)); }
/// <summary> /// Forwards a single-part or all parts of a multi-part message to a destination socket. /// </summary> /// <remarks> /// This method is useful for implementing devices as data is not marshalled into managed code; it /// is forwarded directly in the unmanaged layer. As an example, this method could forward all traffic /// from a device's front-end socket to its backend socket. /// </remarks> /// <param name="destination">A <see cref="ZmqSocket"/> that will receive the incoming message(s).</param> public void Forward(ZmqSocket destination) { if (destination == null) { throw new ArgumentNullException("destination"); } if (_socketProxy.Forward(destination.SocketHandle) == -1) { throw new ZmqSocketException(ErrorProxy.GetLastError()); } }
private TSocket CreateSocket <TSocket>(Func <SocketProxy, TSocket> constructor, SocketType socketType) where TSocket : ZmqSocket { EnsureNotDisposed(); IntPtr socketHandle = _contextProxy.CreateSocket((int)socketType); if (socketHandle == IntPtr.Zero) { throw new ZmqException(ErrorProxy.GetLastError()); } return(constructor(new SocketProxy(socketHandle))); }
/// <summary> /// Create a <see cref="ZmqContext"/> instance. /// </summary> /// <param name="threadPoolSize">Number of threads to use in the ZMQ thread pool.</param> /// <returns>A <see cref="ZmqContext"/> instance with the specified thread pool size.</returns> public static ZmqContext Create(int threadPoolSize) { if (threadPoolSize < 0) { throw new ArgumentOutOfRangeException("threadPoolSize", threadPoolSize, "Thread pool size must be non-negative."); } var contextProxy = new ContextProxy(threadPoolSize); if (contextProxy.Initialize() == -1) { throw new ZmqException(ErrorProxy.GetLastError()); } return(new ZmqContext(contextProxy)); }
/// <summary> /// Queue a message buffer to be sent by the socket in blocking mode. /// </summary> /// <param name="buffer">A <see cref="byte"/> array that contains the message to be sent.</param> /// <param name="size">The size of the message to send.</param> /// <param name="flags">A combination of <see cref="SocketFlags"/> values to use when sending.</param> /// <returns>The number of bytes sent by the socket.</returns> /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException"><paramref name="size"/> is a negative value or is larger than the length of <paramref name="buffer"/>.</exception> /// <exception cref="ZmqSocketException">An error occurred sending data to a remote endpoint.</exception> /// <exception cref="ObjectDisposedException">The <see cref="ZmqSocket"/> has been closed.</exception> /// <exception cref="NotSupportedException">The current socket type does not support Send operations.</exception> public virtual int Send(byte[] buffer, int size, SocketFlags flags) { EnsureNotDisposed(); if (buffer == null) { throw new ArgumentNullException("buffer"); } if (size < 0 || size > buffer.Length) { throw new ArgumentOutOfRangeException("size", "Expected a non-negative value less than or equal to the buffer length."); } int sentBytes = _socketProxy.Send(buffer, size, (int)flags); if (sentBytes >= 0) { SendStatus = (sentBytes == size || LibZmq.MajorVersion < LatestVersion) ? SendStatus.Sent : SendStatus.Incomplete; return(sentBytes); } if (ErrorProxy.ShouldTryAgain) { SendStatus = SendStatus.TryAgain; return(-1); } if (ErrorProxy.ContextWasTerminated) { SendStatus = SendStatus.Interrupted; return(-1); } throw new ZmqSocketException(ErrorProxy.GetLastError()); }