/// <summary>
/// 数据流异步读
/// </summary>
/// <param name="stream">数据流</param>
/// <param name="state">绑定用户对象</param>
/// <param name="memoryStream">目标字节流</param>
public streamEndReader(Stream stream, object state, memoryStream memoryStream)
{
this.stream = stream;
try
{
this.memoryStream = memoryStream ?? new memoryStream();
stream.BeginRead(this.memoryStream.UnsafeArray, this.memoryStream.Length, this.memoryStream.UnsafeArray.Length - this.memoryStream.Length, onRead, state);
}
catch (Exception error)
{
this.error = error;
completed();
}
}
/// <summary>
/// 序列化
/// </summary>
/// <param name="map">成员位图</param>
/// <param name="serializeSize">序列化字节长度</param>
/// <param name="stream">数据流</param>
public static unsafe void Serialize(byte[] map, int serializeSize, memoryStream stream)
{
if (map == null)
{
stream.PrepLength(serializeSize);
fixed(byte *dataFixed = stream.Array)
{
fastCSharp.unsafer.memory.Fill(dataFixed + stream.Length, 0xffffffffU, serializeSize >> 2);
}
stream.Unsafer.AddLength(serializeSize);
}
else
{
stream.Write(map, 0, serializeSize);
}
}
/// <summary>
/// 解压缩数据
/// </summary>
/// <param name="compressData">压缩数据</param>
/// <param name="type">压缩类型</param>
/// <param name="startIndex">起始位置</param>
/// <param name="count">解压缩字节数</param>
/// <returns>解压缩后的数据</returns>
public static memoryStream getDeCompressStream(this byte[] compressData, compression type, int startIndex, int count)
{
array.range range = new array.range(compressData.length(), startIndex, count);
if (count == range.GetCount)
{
using (Stream memoryStream = new MemoryStream(compressData, 0, compressData.Length))
using (Stream compressStream = memoryStream.toCompressStream(CompressionMode.Decompress, false, type))
{
memoryStream dataStream = new memoryStream(compressData.Length);
byte[] buffer = new byte[config.pub.Default.StreamBufferLength];
for (int readLength = compressStream.Read(buffer, 0, config.pub.Default.StreamBufferLength);
readLength != 0;
readLength = compressStream.Read(buffer, 0, config.pub.Default.StreamBufferLength))
{
dataStream.Write(buffer, 0, readLength);
}
return dataStream;
}
}
else if (count == 0) return null;
log.Default.Throw(log.exceptionType.IndexOutOfRange);
return null;
}
/// <summary>
/// 异步读
/// </summary>
/// <param name="stream">数据流</param>
/// <param name="state">绑定用户对象</param>
/// <param name="memoryStream">目标字节流</param>
/// <returns>异步任务</returns>
public static streamEndReader readToEndAsync(this Stream stream, object state = null, memoryStream memoryStream = null)
{
return new streamEndReader(stream, state, memoryStream);
}
/// <summary>
/// 数据流异步读
/// </summary>
/// <param name="stream">数据流</param>
/// <param name="state">绑定用户对象</param>
/// <param name="memoryStream">目标字节流</param>
public streamEndReader(Stream stream, object state, memoryStream memoryStream)
{
this.stream = stream;
try
{
this.memoryStream = memoryStream ?? new memoryStream();
stream.BeginRead(this.memoryStream.Array, this.memoryStream.Length, this.memoryStream.Array.Length - this.memoryStream.Length, onRead, state);
}
catch (Exception error)
{
this.error = error;
completed();
}
}
/// <summary>
/// 序列化
/// </summary>
/// <param name="stream">序列化流</param>
/// <param name="memberMap">成员位图接口</param>
public serializer(memoryStream stream, fastCSharp.setup.cSharp.IMemberMap memberMap) : base(stream, memberMap)
{
}
/// <summary>
/// 异步读
/// </summary>
/// <param name="stream">数据流</param>
/// <param name="state">绑定用户对象</param>
/// <param name="memoryStream">目标字节流</param>
/// <returns>异步任务</returns>
public static streamEndReader readToEndAsync(this Stream stream, object state, memoryStream memoryStream)
{
return(new streamEndReader(stream, state, memoryStream));
}
public void Serialize(memoryStream stream)
{
}
/// <summary>
/// 序列化
/// </summary>
/// <param name="stream">数据流</param>
public void Serialize(memoryStream stream)
{
stream.Write(map);
}
/// <summary>
/// 序列化
/// </summary>
/// <param name="stream">数据流</param>
public unsafe void Serialize(memoryStream stream)
{
fastCSharp.setup.cSharp.memberMap.Serialize(map, SerializeSize, stream);
}
