/// <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)); }