介绍开源的.net通信框架NetworkComms框架 源码分析（十四）StreamTools

原文网址： http://www.cnblogs.com/csdev

Networkcomms 是一款C# 语言编写的TCP/UDP通信框架  作者是英国人  以前是收费的 目前作者已经开源  许可是:Apache License v2

开源地址是:https://github.com/MarcFletcher/NetworkComms.Net

数据流相关工具

  public static class StreamTools
    {
        #region Static Stream Tools

        /// <summary>
        /// Write the provided sendbuffer to the destination stream in chunks of writeBufferSize. Throws exception if any write takes longer than timeoutPerByteWriteMS.
        /// 把发送缓冲区中的数据写入目标数据流中  每次写入的大小为 writeBufferSize.
        /// 如果写入的时间超过 timeoutPerByteWriteMS  将抛出异常
        /// </summary>
        /// <param name="sendBuffer">发送缓冲区Buffer containing data to write</param>
        /// <param name="inputStart">开始位置  The start position in sendBuffer</param>
        /// <param name="bufferLength">需要写入的字节的大小 The number of bytes to write</param>
        /// <param name="destinationStream">目标数据流 The destination stream</param>
        /// <param name="writeBufferSize">每次写入的缓冲区大小 The size in bytes of each successive write</param>
        /// <param name="timeoutMSPerKBWrite">每KB写入的超时时间 The maximum time to allow for write to complete per KB</param>
        /// <param name="minTimeoutMS">最小超时时间  The minimum time to allow for any sized write</param>
        /// <returns>每KB数据的平均发送时间  The average time in milliseconds per KB written</returns>
        public static double Write(byte[] sendBuffer, int inputStart, int bufferLength, Stream destinationStream, int writeBufferSize, double timeoutMSPerKBWrite, int minTimeoutMS)
        {
            if (sendBuffer == null) throw new ArgumentNullException("sendBuffer");
            if (destinationStream == null) throw new ArgumentNullException("destinationStream");

            using (MemoryStream ms = new MemoryStream(sendBuffer))
            {
                return Write(ms, inputStart, bufferLength, destinationStream, writeBufferSize, timeoutMSPerKBWrite, minTimeoutMS);
            }
        }

        /// <summary>
        /// Write the provided input stream to the destination stream in chunks of writeBufferSize. Throws exception if any write takes longer than timeoutPerByteWriteMS.
        ///把发送缓冲区中的数据写入目标数据流中  每次写入的大小为 writeBufferSize.
        /// 如果写入的时间超过 timeoutPerByteWriteMS  将抛出异常
        /// </summary>
        /// <param name="inputStream">输入的数据流  Input stream containing data to send</param>
        /// <param name="inputStart">输入数据流的开始位置  The start position in inputStream</param>
        /// <param name="inputLength">需写入的数据的大小  The number of bytes to write</param>
        /// <param name="destinationStream">目标数据流 The destination stream</param>
        /// <param name="writeBufferSize">写入数据的缓冲区大小 The size in bytes of each successive write, recommended 8K</param>
        /// <param name="timeoutMSPerKBWrite">每KB数据的超时时间  The maximum time to allow for write to complete per KB</param>
        /// <param name="minTimeoutMS">最小超时时间  The minimum time to wait per write, this takes priority over other values.</param>
        /// <returns>数据的平均发送时间  The average time in milliseconds per KB written</returns>
        public static double Write(Stream inputStream, long inputStart, long inputLength, Stream destinationStream, int writeBufferSize, double timeoutMSPerKBWrite, int minTimeoutMS)
        {
            if (inputStream == null) throw new ArgumentNullException("source");
            if (destinationStream == null) throw new ArgumentNullException("destination");

            //Make sure we start in the right place
            //确保我们开始于正确的位置
            inputStream.Seek(inputStart, SeekOrigin.Begin);
            ;
            long bytesRemaining = inputLength;

            int writeWaitTimeMS = Math.Max(minTimeoutMS, (int)((writeBufferSize / 1024.0) * timeoutMSPerKBWrite));

            System.Diagnostics.Stopwatch timerTotal = new System.Diagnostics.Stopwatch();
            timerTotal.Start();

            byte[] bufferA = new byte[writeBufferSize];
            byte[] bufferB = new byte[writeBufferSize];
            AutoResetEvent readCanStartSignal = new AutoResetEvent(true);
            AutoResetEvent allDataWritten = new AutoResetEvent(false);
            Exception innerException = null;

#if NETFX_CORE
            Action readAction = null; Action<int> writeAction = null;

            Stream input = inputStream;
            Stream output = destinationStream;

            readAction = new Action(async () =>
            {
                try
                {
                while (true)  {

                , (writeBufferSize > bytesRemaining ? (int)bytesRemaining : writeBufferSize));
#else
            AsyncCallback readCompleted = null, writeCompleted = null;

            readCompleted = new AsyncCallback((IAsyncResult ar) =>

            {
                try
                {
                    var streams = ar.AsyncState as Stream[];
                    ];
                    ];

                    // input read asynchronously completed
                    //完成异步读取输入的数据
                    int bytesRead = input.EndRead(ar);
#endif
#if NET2
                    if (!readCanStartSignal.WaitOne(writeWaitTimeMS, false))
#else
                    if (!readCanStartSignal.WaitOne(writeWaitTimeMS))
#endif
                        innerException = new TimeoutException("Write timed out after " + writeWaitTimeMS.ToString() + "ms");

                     || innerException != null)
                    {
                        allDataWritten.Set();
                        return;
                    }

                    var temp = bufferA;
                    bufferA = bufferB;
                    bufferB = temp;

                    // write asynchronously
                    //异步写入
#if NETFX_CORE
                writeAction(bytesRead);
#else
                    output.BeginWrite(bufferB, , bytesRead, writeCompleted, streams);
#endif

                    //start the next read straight away
                    //开始下一阶段的读取
                    totalBytesCompleted += bytesRead;
                    bytesRemaining = inputLength - totalBytesCompleted;

#if NETFX_CORE
                }
#else
                    input.BeginRead(bufferA, , (writeBufferSize > bytesRemaining ? (int)bytesRemaining : writeBufferSize), readCompleted, streams);
#endif
                }
                catch (Exception ex)
                {
                    innerException = ex;
                    allDataWritten.Set();
                    return;
                }
            });

#if NETFX_CORE
            writeAction = new Action<int>(async (bytesRead) =>
            {
                try
                {
                , bytesRead);
#else
            writeCompleted = new AsyncCallback((IAsyncResult ar) =>
            {
                try
                {
                    var streams = ar.AsyncState as Stream[];
                    ];
                    ];

                    try
                    {
                        output.EndWrite(ar);
                    }
                    catch (Exception ex)
                    {
                        innerException = ex;
                    }
#endif
                    readCanStartSignal.Set();
                }
                catch (Exception ex)
                {
                    innerException = ex;
                    allDataWritten.Set();
                    return;
                }
            });

#if NETFX_CORE
            readAction();
#else
            inputStream.BeginRead(bufferA, , (writeBufferSize > bytesRemaining ? (int)bytesRemaining : writeBufferSize), readCompleted, new Stream[] { inputStream, destinationStream });
#endif
            allDataWritten.WaitOne();

            timerTotal.Stop();

            if (innerException != null)
                throw innerException;

            ;
            )
                writeTimePerKBms = (double)timerTotal.ElapsedMilliseconds * 1024.0 / inputLength;

            return writeTimePerKBms;
        }

        /// <summary>
        /// Write the provided input stream to the destination stream
        /// 根据参数 把输入流中的数据写入到输出流中
        /// </summary>
        /// <param name="inputStream">输入流  Input stream containing data to send</param>
        /// <param name="destinationStream">输出流  The destination stream</param>
        /// <returns>每KB数据的平均发送时间 The average time in milliseconds per KB written</returns>
        public static double Write(Stream inputStream, Stream destinationStream)
        {
            , inputStream.Length, destinationStream, , , int.MaxValue);
        }

        /// <summary>
        /// Locker for LogError() which ensures thread safe saves.
        /// 同步锁 用于确保线程安全
        /// </summary>
        static object errorLocker = new object();

        /// <summary>
        /// Appends the provided logString to end of fileName.txt. If the file does not exist it will be created.
        /// 把日志写入到日志文件中
        /// </summary>
        /// <param name="fileName">文件名称 The filename to use. The extension .txt will be appended automatically</param>
        /// <param name="logString">写入的信息  The string to append.</param>
        static void AppendStringToLogFile(string fileName, string logString)
        {
            try
            {
                lock (errorLocker)
                {

#if NETFX_CORE
                    string toWrite = DateTime.Now.Hour.ToString() + "." + DateTime.Now.Minute.ToString() + "." + DateTime.Now.Second.ToString() + "." + DateTime.Now.Millisecond.ToString() + " [" + Environment.CurrentManagedThreadId.ToString() + "] " + logString + Environment.NewLine;

                    Func<Task> writeTask = new Func<Task>(async () =>
                    {
                        StorageFolder folder = ApplicationData.Current.LocalFolder;
                        StorageFile file = await folder.CreateFileAsync(fileName + ".txt", CreationCollisionOption.OpenIfExists);
                        await FileIO.AppendTextAsync(file, toWrite);
                    });

                    writeTask().Wait();
#else
                    using (System.IO.StreamWriter sw = new System.IO.StreamWriter(fileName + ".txt", true))
                        sw.WriteLine(DateTime.Now.Hour.ToString() + "." + DateTime.Now.Minute.ToString() + "." + DateTime.Now.Second.ToString() + "." + DateTime.Now.Millisecond.ToString() + " [" + Thread.CurrentThread.ManagedThreadId.ToString() + "] " + logString);
#endif
                }
            }
            catch (Exception)
            {
                //If an error happens here, such as if the file is locked then we lucked out.
                //错误发生在这里，比如日志文件被锁定
            }
        }

        /// <summary>
        /// Return the MD5 hash of the provided memory stream as a string. Stream position will be equal to the length of stream on
        /// return, this ensures the MD5 is consistent.
        /// 返回参数中内存流的MD5哈希值
        /// 流的位置与返回的流的长度相等
        /// 这样确保md5 是一致的
        /// </summary>
        /// <param name="streamToMD5">数据流  The bytes which will be checksummed</param>
        /// <param name="start">开始位置 The start position in the stream</param>
        /// <param name="length">长度  The length in the stream to MD5</param>
        /// <returns>生成的MD5字符型检验和  The MD5 checksum as a string</returns>
        public static string MD5(Stream streamToMD5, long start, int length)
        {
            if (streamToMD5 == null) throw new ArgumentNullException("streamToMD5", "Provided Stream cannot be null.");

            using (MemoryStream stream = new MemoryStream(length))
            {
                StreamTools.Write(streamToMD5, start, length, stream, , , );
                return MD5(stream);
            }
        }

        /// <summary>
        /// Return the MD5 hash of the provided byte array as a string
        /// 根据参数中的字节数组MD5哈希值
        /// </summary>
        /// <param name="bytesToMd5">字节数组  The bytes which will be checksummed</param>
        /// <returns>返回的Md5值  The MD5 checksum as a string</returns>
        public static string MD5(byte[] bytesToMd5)
        {
            if (bytesToMd5 == null) throw new ArgumentNullException("bytesToMd5", "Provided byte[] cannot be null.");

            , bytesToMd5.Length, false))
                return MD5(stream);
        }

        /// <summary>
        /// Return the MD5 hash of the provided memory stream as a string. Stream position will be equal to the length of stream on
        /// return, this ensures the MD5 is consistent.
        ///  返回参数中内存流的MD5哈希值
        /// 流的位置与返回的流的长度相等
        /// 这样确保md5 是一致的
        /// </summary>
        /// <param name="streamToMD5">数据流  The bytes which will be checksummed</param>
        /// <returns>返回的Md5哈希值  The MD5 checksum as a string</returns>
        public static string MD5(Stream streamToMD5)
        {
            if (streamToMD5 == null) throw new ArgumentNullException("streamToMD5", "Provided Stream cannot be null.");

            string resultStr;

#if NETFX_CORE
            var alg = Windows.Security.Cryptography.Core.HashAlgorithmProvider.OpenAlgorithm(Windows.Security.Cryptography.Core.HashAlgorithmNames.Md5);
            var buffer = (new Windows.Storage.Streams.DataReader(streamToMD5.AsInputStream())).ReadBuffer((uint)streamToMD5.Length);
            var hashedData = alg.HashData(buffer);
            resultStr = Windows.Security.Cryptography.CryptographicBuffer.EncodeToHexString(hashedData).Replace("-", "");
#else
            using (System.Security.Cryptography.HashAlgorithm md5 =
#if WINDOWS_PHONE
                new Tools.MD5Managed())
#else
 System.Security.Cryptography.MD5.Create())
#endif
            {
                //If we don't ensure the position is consistent the MD5 changes
                streamToMD5.Seek(, SeekOrigin.Begin);
                resultStr = BitConverter.ToString(md5.ComputeHash(streamToMD5)).Replace("-", "");
            }
#endif
            return resultStr;
        }
        #endregion