/// <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);
}
