/// <summary>
/// 继续接收数据
/// </summary>
/// <returns>是否接收成功</returns>
private unsafe void receive()
{
if (isDisposed == 0)
{
try
{
if (this.buffer == null)
{
byte[] buffer = buffers.Get();
bufferIndex = sizeof(int);
fixed(byte *bufferFixed = buffer) * (int *)bufferFixed = 1;
this.buffer = buffer;
}
async.SetBuffer(this.buffer, bufferIndex, packetSize);
if (Socket.ReceiveAsync(async))
{
return;
}
if (async.SocketError != SocketError.Success)
{
socketError = async.SocketError;
}
}
catch (Exception error)
{
lastException = error;
}
Dispose();
}
}
/// <summary>
/// 压缩数据
/// </summary>
/// <param name="data">原始数据</param>
/// <param name="startIndex">起始位置</param>
/// <param name="count">压缩字节数</param>
/// <param name="seek">起始位置</param>
/// <param name="memoryPool">数据缓冲区内存池</param>
/// <returns>压缩后的数据,失败返回null</returns>
internal subArray <byte> GetCompressUnsafe(byte[] data, int startIndex, int count, int seek = 0, memoryPool memoryPool = null)
{
int length = count + seek;
if (memoryPool == null)
{
using (MemoryStream dataStream = new MemoryStream())
{
if (seek != 0)
{
dataStream.Seek(seek, SeekOrigin.Begin);
}
using (Stream compressStream = getStream(dataStream))
{
compressStream.Write(data, startIndex, count);
}
if (dataStream.Position < length)
{
return(subArray <byte> .Unsafe(dataStream.GetBuffer(), seek, (int)dataStream.Position - seek));
}
}
}
else
{
byte[] buffer = memoryPool.Get();
try
{
using (MemoryStream dataStream = memoryStream.UnsafeNew(buffer))
{
if (seek != 0)
{
dataStream.Seek(seek, SeekOrigin.Begin);
}
using (Stream compressStream = getStream(dataStream))
{
compressStream.Write(data, startIndex, count);
}
if (dataStream.Position < length)
{
byte[] streamBuffer = dataStream.GetBuffer();
if (streamBuffer == buffer)
{
buffer = null;
}
return(subArray <byte> .Unsafe(streamBuffer, seek, (int)dataStream.Position - seek));
}
}
}
catch (Exception error)
{
log.Error.Add(error, null, false);
}
finally
{
memoryPool.PushOnly(buffer);
}
}
return(default(subArray <byte>));
}
/// <summary>
/// 文件流写入器
/// </summary>
/// <param name="fileName">文件全名</param>
/// <param name="mode">打开方式</param>
/// <param name="fileShare">共享访问方式</param>
/// <param name="fileOption">附加选项</param>
/// <param name="isLog">是否写日志</param>
/// <param name="encoding">文件编码</param>
public fileStreamWriter(string fileName, FileMode mode = FileMode.CreateNew, FileShare fileShare = FileShare.None, FileOptions fileOption = FileOptions.None, bool isLog = true, Encoding encoding = null)
{
if (string.IsNullOrEmpty(fileName))
{
log.Error.Throw(log.exceptionType.Null);
}
FileName = fileName;
this.isLog = isLog;
this.fileShare = fileShare;
this.fileOption = fileOption;
this.encoding = encoding;
memoryPool = memoryPool.GetOrCreate(bufferLength = (int)file.BytesPerCluster(fileName));
buffer = memoryPool.Get();
open(mode);
flushWait = new EventWaitHandle(true, EventResetMode.ManualReset);
}
/// <summary>
/// 获取缩略图
/// </summary>
/// <param name="data">输出数据</param>
/// <param name="width">缩略宽度</param>
/// <param name="height">缩略高度</param>
/// <param name="type">目标图像文件格式</param>
/// <param name="backColor">背景色</param>
/// <param name="memoryPool">输出数据缓冲区内存池</param>
/// <param name="seek">输出数据起始位置</param>
public void Pad(ref subArray <byte> data, ref int width, ref int height, ImageFormat type, Color backColor, memoryPool memoryPool, int seek)
{
if (checkPad(ref width, ref height))
{
if (memoryPool == null)
{
using (MemoryStream stream = new MemoryStream())
{
if (seek != 0)
{
stream.Seek(seek, SeekOrigin.Begin);
}
pad(stream, width, height, type, backColor);
data.UnsafeSet(stream.GetBuffer(), seek, (int)stream.Position - seek);
return;
}
}
byte[] buffer = memoryPool.Get();
try
{
using (MemoryStream stream = memoryStream.UnsafeNew(buffer))
{
if (seek != 0)
{
stream.Seek(seek, SeekOrigin.Begin);
}
pad(stream, width, height, type, backColor);
byte[] bufferData = stream.GetBuffer();
if (buffer == bufferData)
{
buffer = null;
//showjim
if ((int)stream.Position > bufferData.Length)
{
log.Error.Add("Position " + ((int)stream.Position).toString() + " > " + bufferData.Length.toString(), null, false);
}
}
data.UnsafeSet(bufferData, seek, (int)stream.Position - seek);
return;
}
}
finally { memoryPool.PushOnly(buffer); }
}
data.Null();
}
///// <summary>
///// 字符串转换成字节数组
///// </summary>
///// <param name="value">字符串</param>
///// <returns>字节数组+缓冲区入池调用</returns>
//[MethodImpl((MethodImplOptions)fastCSharp.pub.MethodImplOptionsAggressiveInlining)]
//internal unsafe memoryPool.pushSubArray GetBytes(string value)
//{
// return GetBytes(value, this.encoding ?? fastCSharp.config.appSetting.Encoding);
//}
/// <summary>
/// 字符串转换成字节数组
/// </summary>
/// <param name="value">字符串</param>
/// <param name="encoding"></param>
/// <returns>字节数组+缓冲区入池调用</returns>
internal static unsafe memoryPool.pushSubArray GetBytes(string value, Encoding encoding)
{
int length = encoding.CodePage == Encoding.Unicode.CodePage ? value.Length << 1 : encoding.GetByteCount(value);
memoryPool pool = memoryPool.GetDefaultPool(length);
byte[] data = pool.Get(length);
if (encoding.CodePage == Encoding.Unicode.CodePage)
{
fixed(byte *dataFixed = data) unsafer.String.Copy(value, dataFixed);
}
else
{
encoding.GetBytes(value, 0, value.Length, data, 0);
}
return(new memoryPool.pushSubArray {
Value = subArray <byte> .Unsafe(data, 0, length), PushPool = pool
});
}
/// <summary>
/// 获取解压数据
/// </summary>
/// <returns>解压数据</returns>
public unsafe subArray <byte> Get(memoryPool memoryPool)
{
if (memoryPool == null)
{
pointer data = fastCSharp.unmanagedPool.StreamBuffers.Get();
try
{
using (dataStream = new unmanagedStream(data.Byte, fastCSharp.unmanagedPool.StreamBuffers.Size))
{
get();
return(new subArray <byte>(dataStream.GetArray()));
}
}
finally { fastCSharp.unmanagedPool.StreamBuffers.Push(ref data); }
}
else
{
byte[] data = memoryPool.Get();
try
{
fixed(byte *dataFixed = data)
{
using (dataStream = new unmanagedStream(dataFixed, data.Length))
{
get();
if (dataStream.data.data == dataFixed)
{
byte[] buffer = data;
data = null;
return(subArray <byte> .Unsafe(buffer, 0, dataStream.Length));
}
return(new subArray <byte>(dataStream.GetArray()));
}
}
}
finally { memoryPool.PushOnly(data); }
}
}
/// <summary>
/// 文件流写入器
/// </summary>
/// <param name="fileName">文件全名</param>
/// <param name="mode">打开方式</param>
/// <param name="fileShare">共享访问方式</param>
/// <param name="fileOption">附加选项</param>
/// <param name="encoding">文件编码</param>
public fileStreamWriter(string fileName, FileMode mode = FileMode.CreateNew, FileShare fileShare = FileShare.None, FileOptions fileOption = FileOptions.None, bool isLog = true, Encoding encoding = null)
{
if (fileName.length() == 0) log.Error.Throw(log.exceptionType.Null);
FileName = fileName;
this.isLog = isLog;
this.fileShare = fileShare;
this.fileOption = fileOption;
this.encoding = encoding;
memoryPool = memoryPool.GetPool(bufferLength = (int)file.BytesPerCluster(fileName));
buffer = memoryPool.Get();
writeFileHandle = writeFile;
open(mode);
flushWait = new EventWaitHandle(true, EventResetMode.ManualReset);
}
/// <summary>
/// 复制数据到缓冲区
/// </summary>
/// <param name="data">数据</param>
/// <param name="length">数据长度</param>
private unsafe void copy(byte *data, int length)
{
if (isCopyBuffer != 0)
{
memoryPool.pushSubArray[] bufferArray = buffers.array;
int bufferIndex = buffers.length - 1;
subArray <byte> copyBuffer = bufferArray[bufferIndex].Value;
int freeLength = copyBuffer.FreeLength;
if (length <= freeLength)
{
fixed(byte *bufferFixed = copyBuffer.array) unsafer.memory.Copy(data, bufferFixed + copyBuffer.EndIndex, length);
bufferArray[bufferIndex].Value.UnsafeSetLength(copyBuffer.length + length);
if (length == freeLength)
{
isCopyBuffer = 0;
}
return;
}
fixed(byte *bufferFixed = copyBuffer.array) unsafer.memory.Copy(data, bufferFixed + copyBuffer.EndIndex, freeLength);
bufferArray[bufferIndex].Value.UnsafeSetLength(copyBuffer.array.Length);
data += freeLength;
length -= freeLength;
}
do
{
byte[] buffer = memoryPool.TryGet();
if (buffer == null)
{
if (length <= memoryPool.Size)
{
unsafer.memory.Copy(data, buffer = memoryPool.Get(), length);
isCopyBuffer = length == buffer.Length ? (byte)0 : (byte)1;
buffers.Add(new memoryPool.pushSubArray {
Value = subArray <byte> .Unsafe(buffer, 0, length), PushPool = memoryPool
});
return;
}
unsafer.memory.Copy(data, buffer = new byte[length], length);
buffers.Add(new memoryPool.pushSubArray {
Value = subArray <byte> .Unsafe(buffer, 0, length)
});
isCopyBuffer = 0;
return;
}
if (length <= buffer.Length)
{
unsafer.memory.Copy(data, buffer, length);
isCopyBuffer = length == buffer.Length ? (byte)0 : (byte)1;
buffers.Add(new memoryPool.pushSubArray {
Value = subArray <byte> .Unsafe(buffer, 0, length), PushPool = memoryPool
});
return;
}
unsafer.memory.Copy(data, buffer, buffer.Length);
data += buffer.Length;
length -= buffer.Length;
buffers.Add(new memoryPool.pushSubArray {
Value = subArray <byte> .Unsafe(buffer, 0, buffer.Length), PushPool = memoryPool
});
}while (true);
}
/// <summary>
/// 获取解压数据
/// </summary>
/// <returns>解压数据</returns>
public unsafe subArray<byte> Get(memoryPool memoryPool)
{
if (memoryPool == null)
{
pointer data = fastCSharp.unmanagedPool.StreamBuffers.Get();
try
{
using (dataStream = new unmanagedStream(data.Byte, fastCSharp.unmanagedPool.StreamBuffers.Size))
{
get();
return new subArray<byte>(dataStream.GetArray());
}
}
finally { fastCSharp.unmanagedPool.StreamBuffers.Push(ref data); }
}
else
{
byte[] data = memoryPool.Get();
try
{
fixed (byte* dataFixed = data)
{
using (dataStream = new unmanagedStream(dataFixed, data.Length))
{
get();
if (dataStream.Data == dataFixed)
{
byte[] buffer = data;
data = null;
return subArray<byte>.Unsafe(buffer, 0, dataStream.Length);
}
return new subArray<byte>(dataStream.GetArray());
}
}
}
finally { memoryPool.Push(ref data); }
}
}
/// <summary>
/// 压缩数据
/// </summary>
/// <param name="data">原始数据</param>
/// <param name="startIndex">起始位置</param>
/// <param name="count">压缩字节数</param>
/// <param name="seek">起始位置</param>
/// <returns>压缩后的数据,失败返回null</returns>
internal subArray<byte> GetCompressUnsafe(byte[] data, int startIndex, int count, int seek = 0, memoryPool memoryPool = null)
{
int length = count + seek;
if (memoryPool == null)
{
using (MemoryStream dataStream = new MemoryStream())
{
if (seek != 0) dataStream.Seek(seek, SeekOrigin.Begin);
using (Stream compressStream = getStream(dataStream))
{
compressStream.Write(data, startIndex, count);
}
if (dataStream.Position < length)
{
return subArray<byte>.Unsafe(dataStream.GetBuffer(), seek, (int)dataStream.Position - seek);
}
}
}
else
{
byte[] buffer = memoryPool.Get();
try
{
using (MemoryStream dataStream = memoryStream.Get(buffer))
{
if (seek != 0) dataStream.Seek(seek, SeekOrigin.Begin);
using (Stream compressStream = getStream(dataStream))
{
compressStream.Write(data, startIndex, count);
}
if (dataStream.Position < length)
{
byte[] streamBuffer = dataStream.GetBuffer();
if (streamBuffer == buffer) buffer = null;
return subArray<byte>.Unsafe(streamBuffer, seek, (int)dataStream.Position - seek);
}
}
}
catch (Exception error)
{
log.Error.Add(error, null, false);
}
finally
{
memoryPool.Push(ref buffer);
}
}
return default(subArray<byte>);
}