public void Read <TState>(IOCompleteCallback <TState> completeHeader, TState state)
{
this.completeHeader = completeHeader;
this.state = state;
ReadLine(ParseProtocol <TState>, (object)null);
}
void IPipeline.Input <TState>(IOCompleteCallback <TState> callback, TState state)
{
if (!input.Disposed)
{
throw new InvalidOperationException("input packet is not disposed.");
}
try { GetStream().BeginRead(packetBuffer, 0, packetBuffer.Length, CompleteInput <TState>, new object[] { callback, state }); }
catch (IOException) { Interrupte(); }
catch (ObjectDisposedException) { Interrupte(); }
}
public void Input <TState>(IOCompleteCallback <TState> callback, TState state = default(TState))
{
if (reader.Read())
{
callback(this, inputPacket, state);
}
else
{
pipeline.Input(CompleteBufferInput <TState>, new object[] { callback, state });
}
}
/// <summary>
/// 继续读取报文
/// </summary>
/// <typeparam name="TReadState"></typeparam>
/// <param name="callback"></param>
/// <param name="state"></param>
protected void ReadPaket <TReadState>(IOCompleteCallback <TReadState> callback, TReadState state)
{
if (packet != null)
{
// 存在有效报文继续处理
if (packetOffset < packet.Size)
{
callback(pipeline, this.packet, state);
return;
}
packet.Dispose();
}
pipeline.Input(OnPacketRead <TReadState>, new object[] { callback, state });
}
public void Write <TState>(IPacket packet, IOCompleteCallback <TState> callback, TState state)
{
if (!transPacket.Disposed)
{
throw new InvalidOperationException("trans is not completed");
}
this.outputPacket = packet;
this.callback = callback;
this.state = state;
var packetType = !(packet is TunnelPacket) ? (int)TunnelPacketType.Data : (int)((TunnelPacket)packet).Type;
PacketHeaderSerializer.Serialize(packetType, packet.Size, transPacket.Buffer);
var dataSize = Math.Min(BufferPacket.BufferSize - TunnelPacket.HeaderSize, outputPacket.Size);
transPacket.Relive(dataSize + TunnelPacket.HeaderSize);
if (dataSize > 0) // 具备内容
{
Array.Copy(outputPacket.Buffer, 0, transPacket.Buffer, TunnelPacket.HeaderSize, dataSize);
}
tunnelPipeline.TransPipeline.Output(transPacket, CompleteTransOutput <TState>, dataSize);
}
void IPipeline.Output <TState>(IPacket packet, IOCompleteCallback <TState> callback, TState state)
{
if (packet.Disposed)
{
throw new InvalidOperationException("packet is disposed.");
}
var args = new object[] { callback, packet, state, 0 };
if (Interlocked.Exchange(ref outputting, 1) == 1)
{
lock (queueLocker)
{
if (outputQueue == null)
{
outputQueue = new Queue <object[]>(1);
}
outputQueue.Enqueue(args);
}
return;
}
packet.Read(OutputPacket <TState>, args);
}
void IPipeline.Output <TState>(IPacket packet, IOCompleteCallback <TState> callback, TState state)
{
throw new NotImplementedException();
}
void IPipeline.Input <TState>(IOCompleteCallback <TState> callback, TState state)
{
reader.Read(callback, state);
}
public void Output <TState>(IPacket packet, IOCompleteCallback <TState> callback, TState state = default(TState))
{
writer.Write(packet, callback, state);
}
