原文网址： 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