C# Msg.InitDelimiter方法代码示例

        /// <summary>
        /// Ask pipe to terminate. The termination will happen asynchronously
        /// and user will be notified about actual deallocation by 'terminated'
        /// event.
        /// </summary>
        /// <param name="delay">if set to <c>true</c>, the pending messages will be processed
        /// before actual shutdown. </param>
        public void Terminate(bool delay)
        {
            // Overload the value specified at pipe creation.
            m_delay = delay;

            // If terminate was already called, we can ignore the duplicate invocation.
            if (m_state == State.Terminated || m_state == State.DoubleTerminated)
                return;

            // If the pipe is in the phase of async termination, it's going to
            // closed anyway. No need to do anything special here.
            if (m_state == State.Terminating)
                return;

            if (m_state == State.Active)
            {
                // The simple sync termination case. Ask the peer to terminate and wait
                // for the ack.
                SendPipeTerm(m_peer);
                m_state = State.Terminated;
            }
            else if (m_state == State.Pending && !m_delay)
            {
                // There are still pending messages available, but the user calls
                // 'terminate'. We can act as if all the pending messages were read.
                m_outboundPipe = null;
                SendPipeTermAck(m_peer);
                m_state = State.Terminating;
            }
            else if (m_state == State.Pending)
            {
                // If there are pending messages still available, do nothing.
            }
            else if (m_state == State.Delimited)
            {
                // We've already got delimiter, but not term command yet. We can ignore
                // the delimiter and ack synchronously terminate as if we were in
                // active state.
                SendPipeTerm(m_peer);
                m_state = State.Terminated;
            }
            else
            {
                // There are no other states.
                Debug.Assert(false);
            }

            // Stop outbound flow of messages.
            m_outActive = false;

            if (m_outboundPipe != null)
            {
                // Drop any unfinished outbound messages.
                Rollback();

                // Write the delimiter into the pipe. Note that watermarks are not
                // checked; thus the delimiter can be written even when the pipe is full.

                var msg = new Msg();
                msg.InitDelimiter();
                m_outboundPipe.Write(ref msg, false);
                Flush();
            }
        }

        public void InitDelimiter()
        {
            var msg = new Msg();
            msg.InitDelimiter();

            Assert.AreEqual(0, msg.Size);
            Assert.AreEqual(MsgType.Delimiter, msg.MsgType);
            Assert.AreEqual(MsgFlags.None, msg.Flags);
            Assert.IsNull(msg.Data);
            Assert.IsFalse(msg.HasMore);
            Assert.IsTrue(msg.IsDelimiter);
            Assert.IsFalse(msg.IsIdentity);
            Assert.IsTrue(msg.IsInitialised);

            msg.Close();

            Assert.AreEqual(MsgType.Uninitialised, msg.MsgType);
            Assert.IsNull(msg.Data);
        }