/// <summary>
/// 读取uint32
/// </summary>
/// <param name="value"></param>
public void ReadBigEndian(out uint value)
{
value = BinaryPrimitives.ReadUInt32BigEndian(this.span);
this.span = this.span.Slice(sizeof(uint));
}
private static string?GetSniFromClientHello(ReadOnlySpan <byte> clientHello)
{
// Basic structure: https://tools.ietf.org/html/rfc6101#section-5.6.1.2
// Extended structure: https://tools.ietf.org/html/rfc3546#section-2.1
// struct {
// ProtocolVersion client_version; // 2x uint8
// Random random; // 32 bytes
// SessionID session_id; // opaque type
// CipherSuite cipher_suites<2..2^16-1>; // opaque type
// CompressionMethod compression_methods<1..2^8-1>; // opaque type
// Extension client_hello_extension_list<0..2^16-1>;
// } ClientHello;
ReadOnlySpan <byte> p = SkipBytes(clientHello, ProtocolVersionSize + RandomSize);
// Skip SessionID (max size 32 => size fits in 1 byte)
p = SkipOpaqueType1(p);
// Skip cipher suites (max size 2^16-1 => size fits in 2 bytes)
p = SkipOpaqueType2(p, out _);
// Skip compression methods (max size 2^8-1 => size fits in 1 byte)
p = SkipOpaqueType1(p);
// is invalid structure or no extensions?
if (p.IsEmpty)
{
return(null);
}
// client_hello_extension_list (max size 2^16-1 => size fits in 2 bytes)
int extensionListLength = BinaryPrimitives.ReadUInt16BigEndian(p);
p = SkipBytes(p, sizeof(ushort));
if (extensionListLength != p.Length)
{
return(null);
}
string?ret = null;
while (!p.IsEmpty)
{
bool invalid;
string?sni = GetSniFromExtension(p, out p, out invalid);
if (invalid)
{
return(null);
}
if (ret != null && sni != null)
{
return(null);
}
if (sni != null)
{
ret = sni;
}
}
return(ret);
}
private static bool IsMultiSigContract(byte[] script, out int m, out int n, List <ECPoint> points)
{
m = 0; n = 0;
int i = 0;
if (script.Length < 43)
{
return(false);
}
switch (script[i])
{
case (byte)OpCode.PUSHINT8:
m = script[++i];
++i;
break;
case (byte)OpCode.PUSHINT16:
m = BinaryPrimitives.ReadUInt16LittleEndian(script.AsSpan(++i));
i += 2;
break;
case byte b when b >= (byte)OpCode.PUSH1 && b <= (byte)OpCode.PUSH16:
m = b - (byte)OpCode.PUSH0;
++i;
break;
default:
return(false);
}
if (m < 1 || m > 1024)
{
return(false);
}
while (script[i] == (byte)OpCode.PUSHDATA1)
{
if (script.Length <= i + 35)
{
return(false);
}
if (script[++i] != 33)
{
return(false);
}
points?.Add(ECPoint.DecodePoint(script.AsSpan(i + 1, 33), ECCurve.Secp256r1));
i += 34;
++n;
}
if (n < m || n > 1024)
{
return(false);
}
switch (script[i])
{
case (byte)OpCode.PUSHINT8:
if (n != script[++i])
{
return(false);
}
++i;
break;
case (byte)OpCode.PUSHINT16:
if (script.Length < i + 3 || n != BinaryPrimitives.ReadUInt16LittleEndian(script.AsSpan(++i)))
{
return(false);
}
i += 2;
break;
case byte b when b >= (byte)OpCode.PUSH1 && b <= (byte)OpCode.PUSH16:
if (n != b - (byte)OpCode.PUSH0)
{
return(false);
}
++i;
break;
default:
return(false);
}
if (script[i++] != (byte)OpCode.PUSHNULL)
{
return(false);
}
if (script[i++] != (byte)OpCode.SYSCALL)
{
return(false);
}
if (script.Length != i + 4)
{
return(false);
}
if (BitConverter.ToUInt32(script, i) != ApplicationEngine.Neo_Crypto_CheckMultisigWithECDsaSecp256r1)
{
return(false);
}
return(true);
}
private int ParseMessageLength(ReadOnlySpan <byte> buffer)
{
return(BinaryPrimitives.ReadInt32LittleEndian(buffer));
}
public int Input(ReadOnlySpan <byte> data)
{
if (CheckDispose())
{
//检查释放
return(-4);
}
uint temp_una = snd_una;
if (data.Length < IKCP_OVERHEAD)
{
return(-1);
}
var offset = 0;
int flag = 0;
uint maxack = 0;
while (true)
{
uint ts = 0;
uint sn = 0;
uint length = 0;
uint una = 0;
uint conv_ = 0;
ushort wnd = 0;
byte cmd = 0;
byte frg = 0;
if (data.Length - offset < IKCP_OVERHEAD)
{
break;
}
if (IsLittleEndian)
{
conv_ = BinaryPrimitives.ReadUInt32LittleEndian(data.Slice(offset));
offset += 4;
if (conv != conv_)
{
return(-1);
}
cmd = data[offset];
offset += 1;
frg = data[offset];
offset += 1;
wnd = BinaryPrimitives.ReadUInt16LittleEndian(data.Slice(offset));
offset += 2;
ts = BinaryPrimitives.ReadUInt32LittleEndian(data.Slice(offset));
offset += 4;
sn = BinaryPrimitives.ReadUInt32LittleEndian(data.Slice(offset));
offset += 4;
una = BinaryPrimitives.ReadUInt32LittleEndian(data.Slice(offset));
offset += 4;
length = BinaryPrimitives.ReadUInt32LittleEndian(data.Slice(offset));
offset += 4;
}
else
{
conv_ = BinaryPrimitives.ReadUInt32BigEndian(data.Slice(offset));
offset += 4;
if (conv != conv_)
{
return(-1);
}
cmd = data[offset];
offset += 1;
frg = data[offset];
offset += 1;
wnd = BinaryPrimitives.ReadUInt16BigEndian(data.Slice(offset));
offset += 2;
ts = BinaryPrimitives.ReadUInt32BigEndian(data.Slice(offset));
offset += 4;
sn = BinaryPrimitives.ReadUInt32BigEndian(data.Slice(offset));
offset += 4;
una = BinaryPrimitives.ReadUInt32BigEndian(data.Slice(offset));
offset += 4;
length = BinaryPrimitives.ReadUInt32BigEndian(data.Slice(offset));
offset += 4;
}
if (data.Length - offset < length || (int)length < 0)
{
return(-2);
}
switch (cmd)
{
case IKCP_CMD_PUSH:
case IKCP_CMD_ACK:
case IKCP_CMD_WASK:
case IKCP_CMD_WINS:
break;
default:
return(-3);
}
rmt_wnd = wnd;
Parse_una(una);
Shrink_buf();
if (IKCP_CMD_ACK == cmd)
{
if (Itimediff(current, ts) >= 0)
{
Update_ack(Itimediff(current, ts));
}
Parse_ack(sn);
Shrink_buf();
if (flag == 0)
{
flag = 1;
maxack = sn;
}
else if (Itimediff(sn, maxack) > 0)
{
maxack = sn;
}
}
else if (IKCP_CMD_PUSH == cmd)
{
if (Itimediff(sn, rcv_nxt + rcv_wnd) < 0)
{
///instead of ikcp_ack_push
acklist.Enqueue((sn, ts));
if (Itimediff(sn, rcv_nxt) >= 0)
{
var seg = KcpSegment.AllocHGlobal((int)length);
seg.conv = conv_;
seg.cmd = cmd;
seg.frg = frg;
seg.wnd = wnd;
seg.ts = ts;
seg.sn = sn;
seg.una = una;
//seg.len = length; 长度在分配时确定，不能改变
if (length > 0)
{
data.Slice(offset, (int)length).CopyTo(seg.data);
}
Parse_data(seg);
}
}
}
else if (IKCP_CMD_WASK == cmd)
{
// ready to send back IKCP_CMD_WINS in Ikcp_flush
// tell remote my window size
probe |= IKCP_ASK_TELL;
}
else if (IKCP_CMD_WINS == cmd)
{
// do nothing
}
else
{
return(-3);
}
offset += (int)length;
}
if (flag != 0)
{
Parse_fastack(maxack);
}
if (Itimediff(this.snd_una, temp_una) > 0)
{
if (cwnd < rmt_wnd)
{
var mss_ = mss;
if (cwnd < ssthresh)
{
cwnd++;
incr += mss_;
}
else
{
if (incr < mss_)
{
incr = mss_;
}
incr += (mss_ * mss_) / incr + (mss_ / 16);
if ((cwnd + 1) * mss_ <= incr)
{
cwnd++;
}
}
if (cwnd > rmt_wnd)
{
cwnd = rmt_wnd;
incr = rmt_wnd * mss_;
}
}
}
return(0);
}
public override short ReadInt16()
{
return(BinaryPrimitives.ReadInt16LittleEndian(ReadBytes(2)));
}
public override long ReadInt64()
{
return(BinaryPrimitives.ReadInt64LittleEndian(ReadBytes(8)));
}
private static void EncodeMessageLength(int messageLength, Span <byte> destination)
{
Debug.Assert(destination.Length >= MessageDelimiterSize, "Buffer too small to encode message length.");
BinaryPrimitives.WriteUInt32BigEndian(destination, (uint)messageLength);
}
public static WindowUpdateFrame ReadFrom(Frame header, ReadOnlySpan <byte> buffer)
{
int updateSize = BinaryPrimitives.ReadInt32BigEndian(buffer);
return(new WindowUpdateFrame(updateSize, header.StreamId));
}
/// <summary>
/// 读取int16
/// </summary>
/// <param name="value"></param>
public void ReadBigEndian(out short value)
{
value = BinaryPrimitives.ReadInt16BigEndian(this.span);
this.span = this.span.Slice(sizeof(short));
}
public void Save(Stream output, IList <ArchiveFileInfo> files)
{
var entryPosition = _headerSize;
var hashEntryPosition = entryPosition + files.Count * _entrySize;
var namePosition = hashEntryPosition + files.Count * _hashEntrySize;
using var bw = new BinaryWriterX(output);
// Write names
bw.BaseStream.Position = namePosition;
var nameDictionary = new Dictionary <UPath, int>();
foreach (var file in files)
{
if (!nameDictionary.ContainsKey(file.FilePath))
{
nameDictionary.Add(file.FilePath, (int)bw.BaseStream.Position);
}
bw.WriteString(file.FilePath.ToRelative().FullName, Encoding.ASCII, false);
}
var dataPosition = (bw.BaseStream.Position + 0x7F) & ~0x7F;
// Write files
bw.BaseStream.Position = dataPosition;
var xbbHash = new XbbHash();
var fileEntries = new List <XbbFileEntry>();
var hashEntries = new List <XbbHashEntry>();
foreach (var file in files)
{
var offset = bw.BaseStream.Position;
var writtenSize = file.SaveFileData(bw.BaseStream, null);
bw.WriteAlignment(0x80);
var hash = xbbHash.Compute(Encoding.ASCII.GetBytes(file.FilePath.ToRelative().FullName));
fileEntries.Add(new XbbFileEntry
{
offset = (int)offset,
size = (int)writtenSize,
nameOffset = nameDictionary[file.FilePath],
hash = BinaryPrimitives.ReadUInt32BigEndian(hash)
});
hashEntries.Add(new XbbHashEntry
{
hash = BinaryPrimitives.ReadUInt32BigEndian(hash),
index = fileEntries.Count - 1
});
}
// Write file entries
bw.BaseStream.Position = entryPosition;
bw.WriteMultiple(fileEntries);
// Write hash entries
bw.BaseStream.Position = hashEntryPosition;
bw.WriteMultiple(hashEntries.OrderBy(x => x.hash));
// Write header
bw.BaseStream.Position = 0;
bw.WriteType(new XbbHeader
{
entryCount = files.Count
});
}
/// <summary>
/// 读取int32
/// </summary>
/// <param name="value"></param>
public void ReadLittleEndian(out int value)
{
value = BinaryPrimitives.ReadInt32LittleEndian(this.span);
this.span = this.span.Slice(sizeof(int));
}
/// <summary>
/// 读取uint64
/// </summary>
/// <param name="value"></param>
public void ReadLittleEndian(out ulong value)
{
value = BinaryPrimitives.ReadUInt64LittleEndian(this.span);
this.span = this.span.Slice(sizeof(ulong));
}
/// <summary>
/// 读取uint16
/// </summary>
/// <param name="value"></param>
public void ReadLittleEndian(out ushort value)
{
value = BinaryPrimitives.ReadUInt16LittleEndian(this.span);
this.span = this.span.Slice(sizeof(ushort));
}
internal static bool TryReadInt32BigEndian(ReadOnlySpan <byte> source, out int value, ref int cursor)
{
return(TryAdvance(BinaryPrimitives.TryReadInt32BigEndian(source.Slice(cursor, 4), out value), ref cursor, 4));
}
public override void WriteTo(Span <byte> buffer)
{
base.WriteTo(buffer);
BinaryPrimitives.WriteInt32BigEndian(buffer.Slice(Frame.FrameHeaderLength), UpdateSize);
}
private bool IsSupportedFileFormat(ReadOnlySpan<byte> header)
{
return header.Length >= this.HeaderSize && BinaryPrimitives.ReadUInt64BigEndian(header) == PngConstants.HeaderValue;
}
public IEnumerable <(ulong, OracleRequest)> GetRequests(DataCache snapshot)
{
return(snapshot.Find(CreateStorageKey(Prefix_Request).ToArray()).Select(p => (BinaryPrimitives.ReadUInt64BigEndian(p.Key.Key.AsSpan(1)), p.Value.GetInteroperable <OracleRequest>())));
}
public override int ReadInt32()
{
return(BinaryPrimitives.ReadInt32LittleEndian(ReadBytes(4)));
}
internal static bool TryReadUInt64LittleEndian(ReadOnlySpan <byte> source, out ulong value, ref int cursor)
{
return(TryAdvance(BinaryPrimitives.TryReadUInt64LittleEndian(source.Slice(cursor, 8), out value), ref cursor, 8));
}
public (int RequiredBytes, int HeaderLength, int BodyLength) TryRead(ref ReadOnlySequence <byte> input, out Message message)
{
if (input.Length < FramingLength)
{
message = default;
return(FramingLength, 0, 0);
}
Span <byte> lengthBytes = stackalloc byte[FramingLength];
input.Slice(input.Start, FramingLength).CopyTo(lengthBytes);
var headerLength = BinaryPrimitives.ReadInt32LittleEndian(lengthBytes);
var bodyLength = BinaryPrimitives.ReadInt32LittleEndian(lengthBytes.Slice(4));
// Check lengths
ThrowIfLengthsInvalid(headerLength, bodyLength);
var requiredBytes = FramingLength + headerLength + bodyLength;
if (input.Length < requiredBytes)
{
message = default;
return(requiredBytes, 0, 0);
}
try
{
// Decode header
var header = input.Slice(FramingLength, headerLength);
// Decode body
int bodyOffset = FramingLength + headerLength;
var body = input.Slice(bodyOffset, bodyLength);
// Build message
message = new();
if (header.IsSingleSegment)
{
var headersReader = Reader.Create(header.First.Span, _deserializationSession);
DeserializeFast(ref headersReader, message);
}
else
{
var headersReader = Reader.Create(header, _deserializationSession);
DeserializeFast(ref headersReader, message);
}
_deserializationSession.PartialReset();
// Body deserialization is more likely to fail than header deserialization.
// Separating the two allows for these kinds of errors to be propagated back to the caller.
if (body.IsSingleSegment)
{
message.BodyObject = _bodySerializer.Deserialize(body.First.Span, _deserializationSession);
}
else
{
message.BodyObject = _bodySerializer.Deserialize(body, _deserializationSession);
}
return(0, headerLength, bodyLength);
}
finally
{
input = input.Slice(requiredBytes);
_deserializationSession.PartialReset();
}
}
internal static uint ReadUInt32BigEndian(ReadOnlySpan <byte> source, ref int cursor)
{
return(BinaryPrimitives.ReadUInt32BigEndian(source.SliceAndAdvance(ref cursor, 4)));
}
public int TryRead(ref ReadOnlySequence <byte> input, out Message message)
{
message = default;
if (input.Length < 8)
{
return(8);
}
(int, int) ReadLengths(ReadOnlySequence <byte> b)
{
Span <byte> lengthBytes = stackalloc byte[8];
b.Slice(0, 8).CopyTo(lengthBytes);
return(BinaryPrimitives.ReadInt32LittleEndian(lengthBytes), BinaryPrimitives.ReadInt32LittleEndian(lengthBytes.Slice(4)));
}
var(headerLength, bodyLength) = ReadLengths(input);
// Check lengths
ThrowIfLengthsInvalid(headerLength, bodyLength);
var requiredBytes = 8 + headerLength + bodyLength;
if (input.Length < requiredBytes)
{
message = default;
return(requiredBytes);
}
if (headerLength == 0)
{
input = input.Slice(requiredBytes);
message = default;
return(requiredBytes);
}
// decode header
var header = input.Slice(Message.LENGTH_HEADER_SIZE, headerLength);
// decode body
int bodyOffset = Message.LENGTH_HEADER_SIZE + headerLength;
var body = input.Slice(bodyOffset, bodyLength);
// build message
try
{
this.headersSerializer.Deserialize(header, out var headersContainer);
message = new Message
{
Headers = headersContainer
};
// Body deserialization is more likely to fail than header deserialization.
// Separating the two allows for these kinds of errors to be propagated back to the caller.
this.objectSerializer.Deserialize(body, out var bodyObject);
message.BodyObject = bodyObject;
}
finally
{
input = input.Slice(requiredBytes);
}
return(0);
}
internal static short ReadInt16BigEndian(ReadOnlySpan <byte> source, ref int cursor)
{
return(BinaryPrimitives.ReadInt16BigEndian(source.SliceAndAdvance(ref cursor, 2)));
}
static async Task Main(string[] args)
{
// https://docs.microsoft.com/en-us/dotnet/api/system.net.sockets.tcplistener?redirectedfrom=MSDN&view=net-5.0
// Create TcpListener server.
var server = new TcpListener(IPAddress.Parse("127.0.0.1"), 8080);
// Start listening for client requests.
server.Start();
// Buffer for reading data (256 byte)
var buffer = new byte[256];
// Enter the listening loop
while (true)
{
// Waits for a TCP connections, accepts it and returns it as a TcpClient object;
using var client = await server.AcceptTcpClientAsync();
await using var stream = client.GetStream();
int receiveLength;
// Loop to receive all the data sent by the client
while ((receiveLength = await stream.ReadAsync(buffer.AsMemory(0, buffer.Length))) != 0)
{
if (receiveLength < 3)
{
throw new InvalidDataException("Fail to read GET method.");
}
var input = new List <byte>();
do
{
// Translate data bytes to a ASCII string
input.AddRange(buffer);
} while (stream.DataAvailable && await stream.ReadAsync(buffer.AsMemory(0, buffer.Length)) != 0);
var bytes = input.ToArray();
var data = Encoding.UTF8.GetString(bytes);
if (Regex.IsMatch(data, "^GET", RegexOptions.IgnoreCase))
{
var swk = Regex.Match(data, "Sec-WebSocket-Key:(.*)").Groups[1].Value.Trim();
var swka = swk + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
var swkaSha1 = SHA1.Create().ComputeHash(Encoding.UTF8.GetBytes(swka));
var swkaSha1BAse64 = Convert.ToBase64String(swkaSha1);
// HTTP/1.1 defines the sequence CR LF as the end-of-line marker
var sb = new StringBuilder();
sb.AppendLine("HTTP/1.1 101 Switching Protocols");
sb.AppendLine("Connection: Upgrade");
sb.AppendLine("Upgrade: websocket");
sb.AppendLine($"Sec-WebSocket-Accept: {swkaSha1BAse64}");
sb.AppendLine();
var response = Encoding.UTF8.GetBytes(sb.ToString());
await stream.WriteAsync(response.AsMemory(0, response.Length));
}
else
{
var fin = (bytes[0] & 0x80) != 0; // & 0100 0000
var mask = (bytes[1] & 0x80) != 0; // & 0100 0000
var opcode = bytes[0] & 0x0F; // & 0000 1111
var msglen = bytes[1] & 0x7F; // & 0111 1111
var offset = 2;
switch (msglen)
{
case 126:
msglen = BinaryPrimitives.ReadUInt16BigEndian(new ReadOnlySpan <byte>(bytes, 2, 3));
offset = 4;
break;
case 127:
msglen = BinaryPrimitives.ReadUInt16BigEndian(new ReadOnlySpan <byte>(bytes, 2, 7));
offset = 10;
break;
}
if (mask)
{
var decoded = new byte[msglen];
for (var i = 0; i < msglen; i++)
{
decoded[i] =
(byte)(bytes[offset + i + 4] ^ bytes.AsSpan().Slice(offset, 4)[i % 4]);
}
var text = Encoding.UTF8.GetString(decoded);
Console.WriteLine($"{text}");
}
else
{
Console.WriteLine("mask bit not set");
}
}
}
}
;
}
internal static ulong ReadUInt64LittleEndian(ReadOnlySpan <byte> source, ref int cursor)
{
return(BinaryPrimitives.ReadUInt64LittleEndian(source.SliceAndAdvance(ref cursor, 8)));
}
internal static unsafe int ReadUnalignedI4(int *p)
{
return(BinaryPrimitives.ReadInt32LittleEndian(new ReadOnlySpan <byte>(p, sizeof(int))));
}
internal static bool TryReadInt16LittleEndian(ReadOnlySpan <byte> source, out short value, ref int cursor)
{
return(TryAdvance(BinaryPrimitives.TryReadInt16LittleEndian(source.Slice(cursor, 2), out value), ref cursor, 2));
}
public Structs FromSpan_ManualFieldForField_Progressive()
{
Structs all = default;
var span = data.AsSpan();
for (var i = 0; i < OperationsPerInvoke; i++)
{
var from = span;
all.A.a = BinaryPrimitives.ReadUInt32LittleEndian(from);
all.B.b = BinaryPrimitives.ReadUInt16LittleEndian(from);
all.C.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.C.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.C.u1 = from[0];
from = span; all.D.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.D.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.D.u1 = from[0];
from = span; all.E.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.E.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.E.u1 = from[0];
from = span; all.F.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.F.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.F.u1 = from[0];
from = span; all.G.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.G.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.G.u1 = from[0];
from = span; all.H.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.H.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.H.u1 = from[0];
from = span; all.I.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.I.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.I.u1 = from[0];
from = span; all.J.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.J.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.J.u1 = from[0];
from = span; all.K.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.K.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.K.u1 = from[0];
from = span; all.L.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.L.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.L.u1 = from[0];
from = span; all.M.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.M.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.M.u1 = from[0];
from = span; all.N.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.N.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.N.u1 = from[0];
from = span; all.O.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.O.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.O.u1 = from[0];
from = span; all.P.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.P.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.P.u1 = from[0];
from = span; all.Q.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.Q.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.Q.u1 = from[0];
from = span; all.R.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.R.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.R.u1 = from[0];
from = span; all.S.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.S.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.S.u1 = from[0];
from = span; all.T.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.T.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.T.u1 = from[0];
from = span; all.U.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.U.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.U.u1 = from[0];
from = span; all.V.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.V.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.V.u1 = from[0];
from = span; all.W.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.W.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.W.u1 = from[0];
from = span; all.X.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.X.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.X.u1 = from[0];
from = span; all.Y.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.Y.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.Y.u1 = from[0];
from = span; all.Z.u4 = BinaryPrimitives.ReadUInt32LittleEndian(from); from = from.Slice(sizeof(uint)); all.Z.u2 = BinaryPrimitives.ReadUInt16LittleEndian(from); from = from.Slice(sizeof(ushort)); all.Z.u1 = from[0];
#if TEST
if (end != EndOfStreamMarker)
{
throw new InvalidOperationException();
}
#endif
}
return(all);
}
/// <summary>
/// 读取int64
/// </summary>
/// <param name="value"></param>
public void ReadBigEndian(out long value)
{
value = BinaryPrimitives.ReadInt64BigEndian(this.span);
this.span = this.span.Slice(sizeof(long));
}
