/// <summary> /// Create a new point-to-point message queue object. /// </summary> /// <param name="name"> /// Indicates the name of a named queue. Set to null to create /// an unnamed queue. /// </param> /// <param name="maxMessages"> /// Indicates the length of the queue in messages. /// </param> /// <param name="maxMessageSize"> /// Indicates the maximum size of each message in the queue. /// </param> /// <param name="readAccess"> /// Set to true if messages will be read from the queue, false /// if messages will be written to the queue. A read/write /// queue cannot be created. /// </param> /// <param name="flags"> /// Flags indicating how the queue will operate. /// </param> public PointToPointMsgQueue(string name, int maxMessages, int maxMessageSize, bool readAccess, PointToPointMsgQueueFlags flags) { hMsgQueue = IntPtr.Zero; created = false; // Set up the descriptor for the queue, based on the // parameters. MSGQUEUEOPTIONS opt = new MSGQUEUEOPTIONS(); opt.dwFlags = (int)flags; opt.dwMaxMessages = maxMessages; opt.cbMaxMessage = maxMessageSize; opt.bReadAccess = (readAccess ? 1 : 0); // Actually create the queue. hMsgQueue = PointToPointMsgQueuePInvokes.CreateMsgQueue(name, opt); if (hMsgQueue != IntPtr.Zero) { // Get indication of whether we created the queue or // if we just attached to an existing queue. uint err = PointToPointMsgQueuePInvokes.GetLastError(); if (err == 0) { created = true; } else { created = false; } } }
/// <summary> /// Closes the message queue. /// </summary> public void Close() { if (hMsgQueue != IntPtr.Zero) { PointToPointMsgQueuePInvokes.CloseMsgQueue(hMsgQueue); hMsgQueue = IntPtr.Zero; } }
/// <summary> /// Write a new item to the message queue. /// </summary> /// <param name="buffer"> /// Caller-allocated byte array for the data. /// </param> /// <param name="bufferSize"> /// Number of bytes in the caller-allocated buffer. /// </param> /// <param name="timeout"> /// Time-out value in ms for the read. If no messages arrive /// before the time-out occurs, the number of bytes read will /// be zero. /// </param> /// <param name="writeFlags"> /// Can be set to AlertMsg, if an 'alert message' is to be posted /// to the queue. Otherwise, set to zero. /// </param> /// <returns> /// True is returned on a successful write; false otherwise. /// </returns> public bool WriteMsgQueue(byte[] buffer, int bufferSize, int timeout, PointToPointMsgQueueFlags writeFlags) { bool result = PointToPointMsgQueuePInvokes.WriteMsgQueue( hMsgQueue, buffer, bufferSize, timeout, (int)writeFlags); // Check the result and throw exceptions on errors. // ???? return(result); }
/// <summary> /// Wait for the queue to be signaled, indicating, for a read /// queue, that items are in the queue or, for a write queue, /// that the queue is not full and can be written. /// </summary> /// <param name="timeout"> /// Time to wait in ms. Set to -1 for infinite wait. /// </param> /// <returns> /// True if the queue is signaled; false if the time-out passed /// before the queue was ready. /// </returns> public bool Wait(int timeout) { // Wait for the queue to be signaled. Return true if it // is signaled, false if the time-out passes. int res = PointToPointMsgQueuePInvokes.WaitForSingleObject( hMsgQueue, timeout); if (res == 0) { return(true); } return(false); }
/// <summary> /// Read the next item from the message queue. /// </summary> /// <param name="buffer"> /// Caller-allocated byte array for the data. /// </param> /// <param name="bufferSize"> /// Number of bytes in the caller-allocated buffer. /// </param> /// <param name="bytesRead"> /// Return value indicating number of bytes actually read and /// stored in the buffer. /// </param> /// <param name="timeout"> /// Time-out value in ms for the read. If no messages arrive /// before the time-out occurs, the number of bytes read will /// be zero. /// </param> /// <param name="readFlags"> /// Will be set to AlertMsg if the message was written to the /// queue with that flag set. Zero, otherwise. /// </param> /// <returns> /// True is returned on a successful read; false otherwise. /// </returns> public bool ReadMsgQueue(byte[] buffer, int bufferSize, ref int bytesRead, int timeout, ref PointToPointMsgQueueFlags readFlags) { int fl = 0; bool result = PointToPointMsgQueuePInvokes.ReadMsgQueue( hMsgQueue, buffer, bufferSize, ref bytesRead, timeout, ref fl); readFlags = (PointToPointMsgQueueFlags)fl; // Check the result and throw exceptions on errors. // ???? return(result); }