public void Close() { lock (syncLock) { if (inbox != null) { inbox.Close(); if (emptyBoxEvent != null) { emptyBoxEvent.Close(); } } } }
/// <summary> /// This method closes the inbox. All successful calls to <see cref="Open" /> must /// be matched with a call to Close() to ensure that system resources /// are released in a timely manner. Note that it is OK to call Close() /// even if the shared memory block is not open. This method is threadsafe. /// </summary> public unsafe void Close() { lock (syncLock) { if (sharedMem == null) { return; } byte *p; p = sharedMem.Lock(); // Indicate that we're not listening any more if (p != null) { p[InboxListeningOffset] = 0; sharedMem.Unlock(); } #if WINFULL // Wait up to 5 seconds for the receive thread to stop normally before // forcing the issue. int cWaits = 0; do { killThread = true; // Kill the receive thread newMsgEvent.Set(); cWaits++; if (cWaits == 5) { recvThread.Abort(); } } while (!recvThread.Join(1000)); #else newMsgEvent.Set(); killThread = true; Thread.Sleep(5000); recvThread.Abort(); recvThread.Join(); #endif sharedMem.Close(); // Release unmanaged resources newMsgEvent.Close(); emptyBoxEvent.Close(); sharedMem = null; onReceive = null; onDispatch = null; } }
/// <summary> /// This method transmits the byte message array passed to the inbox. Note that /// you may pass <paramref name="message" /> as <c>null</c>. In this case, the method will simply detect /// whether or not the inbox exists and is able to accept a message transmission. /// </summary> /// <param name="message">The message array.</param> /// <param name="maxWait">The maximum time to wait for the transmission to complete.</param> /// <returns><c>true</c> if the operation was successful.</returns> public unsafe bool Send(byte[] message, TimeSpan maxWait) { // See the comment in SharedMemInbox for a description of the // shared memory block format. byte *p; if (message != null && message.Length > maxMsgSize) { throw new ArgumentException("Message is too large.", "message"); } lock (syncLock) { if (inbox == null) { // Initialize the inbox reference. Return <c>false</c> if the inbox // shared memory does not exist or if there's no SharedMemInbox // listening. try { inbox = new SharedMem(); inbox.Open(name, maxMsgSize, SharedMem.OpenMode.OPEN_ONLY); } catch { inbox = null; return(false); } // Here's what the abbreviations mean: // // LT = LillTek // SMI = SharedMemInBox // NME = NewMessageEvent // EBE = EmptyBoxEvent newMsgEvent = new GlobalAutoResetEvent("LT:SMI:NME:" + name); emptyBoxEvent = new GlobalAutoResetEvent("LT:SMI:EBE:" + name); } // Wait for exclusive access to an empty shared memory block and then // send the message. if (emptyBoxEvent == null || !emptyBoxEvent.WaitOne(maxWait, false)) { // $todo: I really shouldn't have to close the inbox here but for // some reason, the emptyBoxEvent is never set in some // situations (like when a service router starts before the // zone or machine router on the computer). At some point, // I'd like to come back and investigate why this is happening. inbox.Close(); newMsgEvent.Close(); emptyBoxEvent.Close(); inbox = null; newMsgEvent = null; emptyBoxEvent = null; return(false); } if (message == null) { emptyBoxEvent.Set(); return(true); } p = inbox.Lock(); try { int cbMax; if (p[SharedMemInbox.InboxListeningOffset] == 0) { return(false); // There's no inbox listening } cbMax = *(int *)&p[SharedMemInbox.MaxMsgSizeOffset]; if (cbMax != maxMsgSize) { throw new Exception("SharedMemInbox MaxMsgSize mismatch."); } for (int i = 0; i < message.Length; i++) { p[SharedMemInbox.MessageOffset + i] = message[i]; } *(int *)&p[SharedMemInbox.CurMsgSizeOffset] = message.Length; newMsgEvent.Set(); } finally { inbox.Unlock(); } } return(true); }