コード例 #1
0
            private void PostSend(PipeAsyncEventArgs ioEventArgs)
            {
                var copyedBytes = Math.Min(bufferSize, ioEventArgs.messageBytesLength - ioEventArgs.messageBytesDone);

                Array.Copy(ioEventArgs.byteArrayForMessage, ioEventArgs.messageBytesDone, ioEventArgs.Buffer, ioEventArgs.Offset, copyedBytes);
                ioEventArgs.Count         = copyedBytes;
                ioEventArgs.LastOperation = PipeAsyncOperation.Send;
                ioEventArgs.AcceptStream.BeginWrite(ioEventArgs.Buffer, ioEventArgs.Offset, ioEventArgs.Count, ioEventArgs.Completed, ioEventArgs);
            }
コード例 #2
0
            private void TryDequeueAndPostSend(PipeAsyncEventArgs ioEventArgs)
            {
                if (TryDequeueOrReset(out byte[] data))
                {
                    ioEventArgs.byteArrayForMessage = data;
                    ioEventArgs.messageBytesLength  = data.Length;
                    ioEventArgs.messageBytesDone    = 0;

                    PostSend(ioEventArgs);
                }
            }
コード例 #3
0
 private void ProcessSend(PipeAsyncEventArgs ioEventArgs)
 {
     ioEventArgs.messageBytesDone += ioEventArgs.BytesTransferred;
     if (ioEventArgs.messageBytesDone < ioEventArgs.messageBytesLength)
     {
         PostSend(ioEventArgs);
     }
     else
     {
         TryDequeueAndPostSend(ioEventArgs);
     }
 }
コード例 #4
0
            private void ProcessReceive(PipeAsyncEventArgs ioEventArgs)
            {
                var length = ioEventArgs.BytesTransferred;

                if (length <= 0)
                {
                    Closing(ioEventArgs);
                    return;
                }

                int copyedBytes;
                int offset = ioEventArgs.Offset;

                do
                {
                    if (!ioEventArgs.IsPrefixReady)
                    {
                        copyedBytes = Math.Min(length, ioEventArgs.prefixBytesLength - ioEventArgs.prefixBytesDone);
                        Array.Copy(ioEventArgs.Buffer, offset, ioEventArgs.byteArrayForPrefix, ioEventArgs.prefixBytesDone, copyedBytes);

                        offset += copyedBytes;
                        length -= copyedBytes;
                        ioEventArgs.prefixBytesDone += copyedBytes;
                        if (ioEventArgs.IsPrefixReady)
                        {
                            ioEventArgs.messageBytesLength  = BitConverter.ToInt32(ioEventArgs.byteArrayForPrefix, 0);
                            ioEventArgs.byteArrayForMessage = new byte[ioEventArgs.messageBytesLength];
                        }
                        if (length == 0)
                        {
                            //没有数据了
                            break;
                        }
                    }

                    copyedBytes = Math.Min(length, ioEventArgs.messageBytesLength - ioEventArgs.messageBytesDone);
                    Array.Copy(ioEventArgs.Buffer, offset, ioEventArgs.byteArrayForMessage, ioEventArgs.messageBytesDone, copyedBytes);

                    offset += copyedBytes;
                    length -= copyedBytes;
                    ioEventArgs.messageBytesDone += copyedBytes;
                    if (ioEventArgs.IsMessageReady)
                    {
                        var bytes = ioEventArgs.byteArrayForMessage;
                        DataReceived?.Invoke(this, new PipeChannelEventArgs(bytes));

                        ioEventArgs.Reset();
                    }
                } while (length > 0);

                PostReceive(ioEventArgs);
            }
コード例 #5
0
            public PipeChannel(PipeStream ioStream, bool isBlocking, int bufferSize = 1024)
            {
                this.ioStream   = ioStream;
                this.isBlocking = isBlocking;
                this.bufferSize = bufferSize;

                var buffer = new byte[bufferSize];

                senderAsyncEventArgs = new PipeAsyncEventArgs();
                senderAsyncEventArgs.AcceptStream = ioStream;
                senderAsyncEventArgs.Buffer       = buffer;
                senderAsyncEventArgs.Offset       = 0;
                senderAsyncEventArgs.Count        = buffer.Length;
                senderAsyncEventArgs.Completed    = new AsyncCallback(IO_Completed);

                buffer = new byte[bufferSize];
                receiverAsyncEventArgs = new PipeAsyncEventArgs();
                receiverAsyncEventArgs.AcceptStream = ioStream;
                receiverAsyncEventArgs.Buffer       = buffer;
                receiverAsyncEventArgs.Offset       = 0;
                receiverAsyncEventArgs.Count        = buffer.Length;
                receiverAsyncEventArgs.Completed    = new AsyncCallback(IO_Completed);
            }
コード例 #6
0
 private void PostReceive(PipeAsyncEventArgs ioEventArgs)
 {
     ioEventArgs.LastOperation = PipeAsyncOperation.Receive;
     ioEventArgs.AcceptStream.BeginRead(ioEventArgs.Buffer, ioEventArgs.Offset, ioEventArgs.Count, ioEventArgs.Completed, ioEventArgs);
 }
コード例 #7
0
 private void Closed(PipeAsyncEventArgs ioEventArgs)
 {
     Disconnected?.Invoke(this, PipeChannelEventArgs.Empty);
 }
コード例 #8
0
 private void Closing(PipeAsyncEventArgs ioEventArgs)
 {
     Closed(ioEventArgs);
 }