| public Read ( byte buffer, int offset, int count ) : int | ||
| buffer | byte | |
| offset | int | |
| count | int | |
| Résultat | int | |
private static byte[] ReadMsg(PipeStream s)
{
var ms = new MemoryStream();
var buffer = new byte[0x1000];
do
{
ms.Write(buffer, 0, s.Read(buffer, 0, buffer.Length));
} while (!s.IsMessageComplete);
return ms.ToArray();
}
protected static byte[] ReadAllBytes(PipeStream stream)
{
var memoryStream = new MemoryStream();
do
{
var buffer = new byte[65536];
int count = stream.Read(buffer, 0, buffer.Length);
memoryStream.Write(buffer, 0, count);
} while (!stream.IsMessageComplete);
return memoryStream.ToArray();
}
static byte[] ReadBytes(PipeStream pipeStream, int length)
{
Assert.True(pipeStream.IsConnected);
byte[] buffer = new byte[length];
Assert.True(length > 0);
buffer[0] = (byte)pipeStream.ReadByte();
if (length > 1)
{
int len = pipeStream.Read(buffer, 1, length - 1);
Assert.Equal(length - 1, len);
}
return buffer;
}
public static int Read(PipeStream stream, byte[] buffer, int offset, int count, bool isAsync, TimeoutHelper timeoutHelper)
{
// 异步时，使用异步方式读取数据
if (isAsync)
{
IAsyncResult asyncResult = stream.BeginRead(buffer, offset, count, null, null);
// 等待 timeoutHelper 计算后的剩余时间，如果在这段时间内没有读到数据，那么将直接返回，这时，由于没有读到数据，返回的数据长度为 0
asyncResult.AsyncWaitHandle.WaitOne(timeoutHelper == null ? 60000 : (int)timeoutHelper.RemainingTime().TotalMilliseconds);
if (asyncResult.GetType() == pipeStreamAsyncResultType)
{
pipeStreamAsyncResult_waitHandle.SetValue(asyncResult, null);
}
return stream.EndRead(asyncResult);
}
// 使用系统内置的方式进行同步阻塞式读取，该方法直到读取到数据才返回
return stream.Read(buffer, offset, count);
}
/// <summary>
/// Rekonstruiert ein Objekt aus dem angegebenen Kommunikationskanal.
/// </summary>
/// <param name="pipe">Der gewünschte Kanal.</param>
/// <param name="serializer">Die Instanz zur Rekonstruktion des Objektes.</param>
/// <returns>Das rekonstruierte Objekt.</returns>
private static object ReadFromPipe( PipeStream pipe, XmlSerializer serializer )
{
// Allocate length field
byte[] len = new byte[sizeof( long )], data;
// Load it
if (len.Length != pipe.Read( len, 0, len.Length ))
return null;
// Lock briefly
var lenLock = GCHandle.Alloc( len, GCHandleType.Pinned );
try
{
// Fill
data = new byte[Marshal.ReadInt64( lenLock.AddrOfPinnedObject() )];
}
finally
{
// Release
lenLock.Free();
}
// Read in blocks
for (int n = 0; n < data.Length; )
{
// Block size
int block = Math.Min( BlockSize, data.Length - n );
// Load chunk
if (pipe.Read( data, n, block ) != block)
return null;
// Advance
n += block;
}
// Create settings
var settings = new XmlReaderSettings { CheckCharacters = false };
// Reconstruct
using (var temp = new MemoryStream( data, false ))
using (var reader = XmlReader.Create( temp, settings ))
return serializer.Deserialize( reader );
}
