public void LittleEndianBitConverter_Double() { const int n = sizeof(Double); const Double pos = Math.PI; const Double zero = 0; const Double neg = -pos; var posRepr = GetCanonicalRepresentation(pos); var negRepr = GetCanonicalRepresentation(neg); // -------------------------------------------------------------- var buffer = new byte[n]; LittleEndianBitConverter.FillBytes(pos, buffer); Assert.IsTrue(buffer.SequenceEqual(posRepr)); Assert.IsTrue(LittleEndianBitConverter.GetBytes(pos).SequenceEqual(buffer)); Assert.AreEqual(pos, LittleEndianBitConverter.ToDouble(buffer)); LittleEndianBitConverter.FillBytes(zero, buffer); Assert.IsTrue(buffer.SequenceEqual(new byte[n])); Assert.IsTrue(LittleEndianBitConverter.GetBytes(zero).SequenceEqual(buffer)); Assert.AreEqual(zero, LittleEndianBitConverter.ToDouble(buffer)); LittleEndianBitConverter.FillBytes(neg, buffer); Assert.IsTrue(buffer.SequenceEqual(negRepr)); Assert.IsTrue(LittleEndianBitConverter.GetBytes(neg).SequenceEqual(buffer)); Assert.AreEqual(neg, LittleEndianBitConverter.ToDouble(buffer)); }
public void ToXXX() { var sut = new LittleEndianBitConverter(); var data = new byte[] { 0x03, 0, 0, 0, 0, 0, 0, 0 }; Check.That(sut.ToBoolean(data, 0)).IsTrue(); Check.That(sut.ToBoolean(data, 7)).IsFalse(); Check.That(sut.ToChar(data, 0)).IsEqualTo('\u0003'); Check.That(sut.ToChar(data, 6)).IsEqualTo('\0'); Check.That(sut.ToInt16(data, 0)).IsEqualTo(3); Check.That(sut.ToInt16(data, 6)).IsEqualTo(0); Check.That(sut.ToUInt16(data, 0)).IsEqualTo(3u); Check.That(sut.ToUInt16(data, 6)).IsEqualTo(0u); Check.That(sut.ToInt32(data, 0)).IsEqualTo(3); Check.That(sut.ToInt32(data, 4)).IsEqualTo(0); Check.That(sut.ToUInt32(data, 0)).IsEqualTo(3u); Check.That(sut.ToUInt32(data, 4)).IsEqualTo(0u); Check.That(sut.ToInt64(data, 0)).IsEqualTo(3L); Check.That(sut.ToUInt64(data, 0)).IsEqualTo(3UL); data = new byte[] { 0, 0, 0, 0, 0, 0, 0x20, 0x41 }; Check.That(sut.ToSingle(data, 0)).IsEqualTo(0.0f); Check.That(sut.ToSingle(data, 4)).IsEqualTo(10.0f); data = new byte[] { 0, 0, 0, 0, 0, 0, 0x24, 0x40 }; Check.That(sut.ToDouble(data, 0)).IsEqualTo(10.0); }
public unsafe int imethod_11() { int num; switch (this.imethod_13()) { case 0: fixed(byte *pointer = this.byte_5) { this.method_1(pointer); num = LittleEndianBitConverter.ToInt32(this.byte_5); } break; case 1: if (this.int_0 == 0) { this.method_6(); num = (int)this.byte_3; break; } num = (int)this.method_7(); break; case 2: num = 0; break; default: throw new DxfException("Illegal int."); } return(num); }
public void Write() { this.stream_0.Write(Class328.byte_0, 0, Class328.byte_0.Length); this.stream_0.Write(LittleEndianBitConverter.GetBytes(1), 0, 4); this.stream_0.WriteByte((byte)0); this.stream_0.Write(Class328.byte_1, 0, Class328.byte_1.Length); }
public void LittleEndianBitConverter_Int32() { const int n = sizeof(Int32); const Int32 pos = 0x11223344; const Int32 zero = 0; const Int32 neg = -pos; var posRepr = new byte[] { 0x44, 0x33, 0x22, 0x11 }; // -------------------------------------------------------------- var buffer = new byte[n]; LittleEndianBitConverter.FillBytes(pos, buffer); Assert.IsTrue(buffer.SequenceEqual(posRepr)); Assert.IsTrue(LittleEndianBitConverter.GetBytes(pos).SequenceEqual(buffer)); Assert.AreEqual(pos, LittleEndianBitConverter.ToInt32(buffer)); LittleEndianBitConverter.FillBytes(zero, buffer); Assert.IsTrue(buffer.SequenceEqual(new byte[n])); Assert.IsTrue(LittleEndianBitConverter.GetBytes(zero).SequenceEqual(buffer)); Assert.AreEqual(zero, LittleEndianBitConverter.ToInt32(buffer)); LittleEndianBitConverter.FillBytes(neg, buffer); Assert.IsTrue(buffer.SequenceEqual(Neg(posRepr))); Assert.IsTrue(LittleEndianBitConverter.GetBytes(neg).SequenceEqual(buffer)); Assert.AreEqual(neg, LittleEndianBitConverter.ToInt32(buffer)); }
public void LittleEndianBitConverter_Decimal() { const int n = sizeof(Decimal); const Decimal pos = 3.1415926535897932384626433833m; const Decimal zero = 0; const Decimal neg = -pos; var posRepr = GetCanonicalRepresentation(pos); var negRepr = GetCanonicalRepresentation(neg); // -------------------------------------------------------------- var buffer = new byte[n]; LittleEndianBitConverter.FillBytes(pos, buffer); Assert.IsTrue(buffer.SequenceEqual(posRepr)); Assert.IsTrue(LittleEndianBitConverter.GetBytes(pos).SequenceEqual(buffer)); Assert.AreEqual(pos, LittleEndianBitConverter.ToDecimal(buffer)); LittleEndianBitConverter.FillBytes(zero, buffer); Assert.IsTrue(buffer.SequenceEqual(new byte[n])); Assert.IsTrue(LittleEndianBitConverter.GetBytes(zero).SequenceEqual(buffer)); Assert.AreEqual(zero, LittleEndianBitConverter.ToDecimal(buffer)); LittleEndianBitConverter.FillBytes(neg, buffer); Assert.IsTrue(buffer.SequenceEqual(negRepr)); Assert.IsTrue(LittleEndianBitConverter.GetBytes(neg).SequenceEqual(buffer)); Assert.AreEqual(neg, LittleEndianBitConverter.ToDecimal(buffer)); }
public static List <byte[]> SplitData( byte[] data, int blockSize ) { if (data == null || data.Length == 0) { throw new ArgumentNullException(); } if (blockSize <= 0) { throw new ArgumentOutOfRangeException(); } uint blockCount = GetBlocksCount((uint)data.Length, (uint)blockSize); var result = new List <byte[]>(); var inStream = new MemoryStream(data); var littleEndianConverter = new LittleEndianBitConverter(); var binaryReader = new EndianBinaryReader( littleEndianConverter, inStream ); for (int i = 0; i < blockCount; i++) { var elem = binaryReader.ReadBytes(blockSize); result.Add(elem); } return(result); }
public Class995() { Random random = new Random(); byte[] numArray = new byte[8]; random.NextBytes(numArray); this.method_0(LittleEndianBitConverter.ToUInt64(numArray)); }
public void Write(Stream stream) { stream.Write(LittleEndianBitConverter.GetBytes(this.ulong_0), 0, 8); stream.Write(LittleEndianBitConverter.GetBytes(this.ulong_1), 0, 8); stream.Write(LittleEndianBitConverter.GetBytes(this.ulong_2), 0, 8); stream.Write(LittleEndianBitConverter.GetBytes(this.ulong_3), 0, 8); stream.Write(LittleEndianBitConverter.GetBytes(this.ulong_4), 0, 8); }
public void ToXXX_ThrowsOnInvalidIndexOrSize() { var sut = new LittleEndianBitConverter(); var data = new byte[3]; Check.ThatCode(() => sut.ToInt32(data, 0)).Throws <ArgumentOutOfRangeException>(); data = new byte[4]; Check.ThatCode(() => sut.ToInt32(data, 1)).Throws <ArgumentOutOfRangeException>(); }
public AgarClient(DefaultPacketManager pm) { world = new AgarWorld(); bc = new LittleEndianBitConverter(); wait_useraction = new AutoResetEvent(false); pacman = pm; userActions_l = new object(); userActions = new Queue <AgarPacket>(); }
public void GetBytes() { var sut = new LittleEndianBitConverter(); Check.That(new byte[] { 0 }).ContainsExactly(sut.GetBytes(false)); Check.That(new byte[] { 1 }).ContainsExactly(sut.GetBytes(true)); Check.That(new byte[] { 0, 0 }).ContainsExactly(sut.GetBytes((short)0)); Check.That(new byte[] { 1, 0 }).ContainsExactly(sut.GetBytes((short)1)); Check.That(new byte[] { 0, 1 }).ContainsExactly(sut.GetBytes((short)256)); Check.That(new byte[] { 255, 255 }).ContainsExactly(sut.GetBytes((short)-1)); Check.That(new byte[] { 0, 0 }).ContainsExactly(sut.GetBytes((ushort)0)); Check.That(new byte[] { 1, 0 }).ContainsExactly(sut.GetBytes((ushort)1)); Check.That(new byte[] { 0, 1 }).ContainsExactly(sut.GetBytes((ushort)256)); Check.That(new byte[] { 255, 255 }).ContainsExactly(sut.GetBytes(ushort.MaxValue)); Check.That(new byte[] { 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(0)); Check.That(new byte[] { 1, 0, 0, 0 }).ContainsExactly(sut.GetBytes(1)); Check.That(new byte[] { 0, 1, 0, 0 }).ContainsExactly(sut.GetBytes(256)); Check.That(new byte[] { 0, 0, 1, 0 }).ContainsExactly(sut.GetBytes(65536)); Check.That(new byte[] { 0, 0, 0, 1 }).ContainsExactly(sut.GetBytes(16777216)); Check.That(new byte[] { 255, 255, 255, 255 }).ContainsExactly(sut.GetBytes(-1)); Check.That(new byte[] { 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(0u)); Check.That(new byte[] { 1, 0, 0, 0 }).ContainsExactly(sut.GetBytes(1u)); Check.That(new byte[] { 0, 1, 0, 0 }).ContainsExactly(sut.GetBytes(256u)); Check.That(new byte[] { 0, 0, 1, 0 }).ContainsExactly(sut.GetBytes(65536u)); Check.That(new byte[] { 0, 0, 0, 1 }).ContainsExactly(sut.GetBytes(16777216u)); Check.That(new byte[] { 255, 255, 255, 255 }).ContainsExactly(sut.GetBytes(uint.MaxValue)); Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(0L)); Check.That(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(1L)); Check.That(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(256L)); Check.That(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(65536L)); Check.That(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(16777216L)); Check.That(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }).ContainsExactly(sut.GetBytes(4294967296L)); Check.That(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }).ContainsExactly(sut.GetBytes(1099511627776L)); Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }).ContainsExactly(sut.GetBytes(281474976710656L)); Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }).ContainsExactly(sut.GetBytes(72057594037927936L)); Check.That(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }).ContainsExactly(sut.GetBytes(-1L)); Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(0UL)); Check.That(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(1UL)); Check.That(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(256UL)); Check.That(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(65536UL)); Check.That(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(16777216UL)); Check.That(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }).ContainsExactly(sut.GetBytes(4294967296UL)); Check.That(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }).ContainsExactly(sut.GetBytes(1099511627776UL)); Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }).ContainsExactly(sut.GetBytes(281474976710656UL)); Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }).ContainsExactly(sut.GetBytes(72057594037927936UL)); Check.That(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }).ContainsExactly(sut.GetBytes(ulong.MaxValue)); }
public unsafe double imethod_42() { double num; fixed(byte *pointer = this.byte_6) { this.method_2(pointer); num = LittleEndianBitConverter.ToDouble(this.byte_6); } return(num); }
public unsafe ulong imethod_46() { ulong uint64; fixed(byte *pointer = this.byte_6) { this.method_2(pointer); uint64 = LittleEndianBitConverter.ToUInt64(this.byte_6); } return(uint64); }
public unsafe int imethod_43() { int int32; fixed(byte *pointer = this.byte_5) { this.method_1(pointer); int32 = LittleEndianBitConverter.ToInt32(this.byte_5); } return(int32); }
public unsafe ushort method_4() { ushort uint16; fixed(byte *pointer = this.byte_5) { this.method_0(pointer); uint16 = LittleEndianBitConverter.ToUInt16(this.byte_5); } return(uint16); }
public unsafe uint imethod_44() { uint uint32; fixed(byte *pointer = this.byte_5) { this.method_1(pointer); uint32 = LittleEndianBitConverter.ToUInt32(this.byte_5); } return(uint32); }
public unsafe short imethod_45() { short int16; fixed(byte *pointer = this.byte_5) { this.method_0(pointer); int16 = LittleEndianBitConverter.ToInt16(this.byte_5); } return(int16); }
public override void imethod_5(string value) { if (string.IsNullOrEmpty(value)) { this.imethod_13(LittleEndianBitConverter.GetBytes((ushort)0), 0, 2); } else { this.imethod_13(LittleEndianBitConverter.GetBytes((ushort)value.Length), 0, 2); byte[] bytes = Encoding.Unicode.GetBytes(value); this.imethod_13(bytes, 0, bytes.Length); } }
public void LittleEndianBitConverter_Boolean() { var buffer = new byte[1]; LittleEndianBitConverter.FillBytes(true, buffer); Assert.AreEqual(1, buffer[0]); Assert.IsTrue(LittleEndianBitConverter.GetBytes(true).SequenceEqual(buffer)); Assert.AreEqual(true, LittleEndianBitConverter.ToBoolean(buffer)); LittleEndianBitConverter.FillBytes(false, buffer); Assert.AreEqual(0, buffer[0]); Assert.IsTrue(LittleEndianBitConverter.GetBytes(false).SequenceEqual(buffer)); Assert.AreEqual(false, LittleEndianBitConverter.ToBoolean(buffer)); }
/// <summary> /// Write value to stream. /// </summary> /// <param name="s">stream</param> /// <param name="value">value</param> static public void Write(Stream s, byte[] value) { if (value == null) { byte[] lenBuf = LittleEndianBitConverter.GetBytes((int)0);//data length } else { byte[] buf = value; byte[] lenBuf = LittleEndianBitConverter.GetBytes((int)buf.Length); s.Write(lenBuf, 0, lenBuf.Length); //data length s.Write(buf, 0, buf.Length); } }
public void imethod_16(double value) { if (value == 0.0) { this.imethod_15((byte)2); } else if (value == 1.0) { this.imethod_15((byte)1); } else { this.imethod_15((byte)0); this.imethod_12(LittleEndianBitConverter.GetBytes(value)); } }
private unsafe ulong method_3(int count) { if (this.stream_0.Read(this.byte_7, 0, count) < count) { throw new EndOfStreamException(); fixed(byte *numPtr1 = this.byte_6) { if (this.int_0 == 0) { byte *numPtr2 = numPtr1 + count - 1; fixed(byte *numPtr3 = this.byte_7) { byte *numPtr4 = numPtr3; for (int index = 0; index < count; ++index) { *numPtr2-- = *numPtr4++; } } } else { int num1 = 8 - this.int_0; byte *numPtr2 = numPtr1 + count - 1; fixed(byte *numPtr3 = this.byte_7) { byte *numPtr4 = numPtr3; for (int index = 0; index < count; ++index) { byte num2 = (byte)((uint)this.byte_3 << this.int_0); this.byte_3 = *numPtr4++; byte num3 = (byte)((uint)num2 | (uint)(byte)((uint)this.byte_3 >> num1)); * numPtr2-- = num3; } } } byte *numPtr5 = numPtr1 + count; for (int index = count; index < 8; ++index) { *numPtr5++ = (byte)0; } } return(LittleEndianBitConverter.ToUInt64(this.byte_6)); }
public DefaultPacketManager() { this_lock = new object(); websock = new ClientWebSocket(); bc = new LittleEndianBitConverter(); in_packets_l = new object(); in_packets = new Queue <AgarPacket>(); packet_received = new AutoResetEvent(false); out_packets_l = new object(); out_packets = new Queue <AgarPacket>(); packet_sent = new AutoResetEvent(false); hasStarted = false; }
/// <summary> /// Read data from stream /// </summary> /// <param name="s">stream</param> /// <returns>data of specified type</returns> public static byte[] ToData(Stream s) { byte[] lenBuf = new byte[sizeof(int)]; s.Read(lenBuf, 0, lenBuf.Length); int len = LittleEndianBitConverter.ToInt32(lenBuf, 0); if (len == 0) { return(null); } else { byte[] buf = new byte[len]; s.Read(buf, 0, len); return(buf); } }
/// <summary> /// Read data from stream /// </summary> /// <param name="s">stream</param> /// <returns>data of specified type</returns> public static string ToString(Stream s) { byte[] lenBuf = new byte[sizeof(int)]; s.Read(lenBuf, 0, lenBuf.Length); int len = LittleEndianBitConverter.ToInt32(lenBuf, 0); if (len == 0) { return(null); } else { byte[] buf = new byte[len]; s.Read(buf, 0, len); return(Encoding.UTF8.GetString(buf, 0, buf.Length)); } }
private void ReadHeader() { ReadIdentificator(); EndianBitConverter converter; if (Endianess == Endianess.LittleEndian) { converter = new LittleEndianBitConverter(); } else { converter = new BigEndianBitConverter(); } readerSource = () => new EndianBinaryReader( converter, GetNewStream() ); localReaderSource = () => new EndianBinaryReader(converter, new NonClosingStreamWrapper(stream)); ReadFields(); }
private void method_12() { int sectionStartPosition1 = (int)Class653.smethod_0(this.int_0); int num1 = sectionStartPosition1 + (int)this.memoryStream_0.Length; int sectionStartPosition2 = num1 + (int)this.memoryStream_4.Length; int sectionStartPosition3 = sectionStartPosition2 + (int)this.memoryStream_1.Length; int sectionStartPosition4 = sectionStartPosition3 + (int)this.memoryStream_2.Length + (int)this.memoryStream_3.Length + (int)this.memoryStream_5.Length; int sectionStartPosition5 = sectionStartPosition4 + (int)this.memoryStream_6.Length + (int)this.memoryStream_7.Length; MemoryStream memoryStream = new MemoryStream(); Interface29 streamWriter = Class724.Create(this.dxfVersion_0, (Stream)memoryStream, Encodings.GetEncoding((int)this.dxfModel_0.Header.DrawingCodePage)); streamWriter.imethod_13(Encodings.Ascii.GetBytes(this.dxfModel_0.Header.AcadVersionString), 0, 6); Interface29 nterface29 = streamWriter; byte[] numArray = new byte[7]; numArray[5] = (byte)15; numArray[6] = (byte)1; byte[] bytes = numArray; nterface29.imethod_12(bytes); streamWriter.imethod_19(num1); streamWriter.imethod_11((byte)27); streamWriter.imethod_11((byte)25); int num2 = (int)Class952.smethod_1(this.dxfModel_0.Header.DrawingCodePage); streamWriter.imethod_13(LittleEndianBitConverter.GetBytes((short)num2), 0, 2); streamWriter.imethod_13(LittleEndianBitConverter.GetBytes(this.int_0), 0, 4); long position = this.stream_0.Position; this.method_13(streamWriter, (byte)0, sectionStartPosition2, (int)this.memoryStream_1.Length); this.method_13(streamWriter, (byte)1, sectionStartPosition3, (int)this.memoryStream_2.Length); this.method_13(streamWriter, (byte)2, sectionStartPosition4, (int)this.memoryStream_6.Length); this.method_13(streamWriter, (byte)3, 0, 0); this.method_13(streamWriter, (byte)4, sectionStartPosition5, (int)this.memoryStream_9.Length); this.method_13(streamWriter, (byte)5, sectionStartPosition1, (int)this.memoryStream_0.Length); streamWriter.Flush(); ushort num3 = Stream1.smethod_1((ushort)49345, memoryStream.GetBuffer(), 0L, memoryStream.Length); streamWriter.imethod_18((short)num3); streamWriter.imethod_13(Class800.byte_4, 0, Class800.byte_4.Length); this.stream_0.Write(memoryStream.GetBuffer(), 0, (int)memoryStream.Length); }
public Class921(Stream stream, DxfModel model) { if (!stream.CanSeek || !stream.CanWrite) { throw new ArgumentException("Stream must allow writing and seeking."); } this.dxfModel_0 = model; this.stream_0 = stream; this.dxfVersion_0 = model.Header.AcadVersion; this.encoding_0 = Encodings.GetEncoding((int)model.Header.DrawingCodePage); Random random = new Random(); byte[] numArray = new byte[8]; random.NextBytes(numArray); this.class995_0.method_0(LittleEndianBitConverter.ToUInt64(numArray)); this.uint_0 = 0U; this.class954_0.RandomSeed = this.class995_0.Seed; this.class954_0.CrcSeed = (ulong)this.uint_0; this.class954_0.PagesMapCrcSeed = (ulong)this.uint_0; this.class954_0.SectionsMapCrcSeed = (ulong)this.uint_0; }
private void ProcInnerMessage(Event.ReceiveEventArgs message) { try { switch ((InnerEvent)message.Event) { case InnerEvent.GetProcessorId: { //Get processorid and cableid //Only syncronize connection of single connection cable will //Send this event to server to alloc //Processor mask from client ulong mask = LittleEndianBitConverter.ToUInt64(message.Data, 0); //Get Processor id int pId = _AllocClientProcessor.GetProcessorId(((IPEndPoint)message.RemoteIPEndPoint).Address, mask, message.SCBID); //Get cable id SCB scb = GetSCB((IPEndPoint)message.RemoteIPEndPoint); UInt16 cableId = _CableIdAllocator.Alloc(scb.RemoteIPEndPoint); scb.CableId = cableId; message.ReturnData = new byte[sizeof(int) + sizeof(UInt16)]; Array.Copy(LittleEndianBitConverter.GetBytes(pId), 0, message.ReturnData, 0, sizeof(int)); Array.Copy(LittleEndianBitConverter.GetBytes(cableId), 0, message.ReturnData, sizeof(int), sizeof(UInt16)); } break; } } catch (Exception e) { OnErrorEvent("ProcInnerMessage", e); } }
public static byte[] GetSentTransfer20151004ArgsHmacAuthCode( SendTransfer20151004Args request, byte[] hmacKey ) { Assert.NotNull(request); CheckSentTransfer20151004Args(request); Assert.NotNull(hmacKey); Assert.Equal(hmacKey.Length, 64); using (var ms = new MemoryStream()) { var converter = new LittleEndianBitConverter(); using (var littleStream = new EndianBinaryWriter(converter, ms)) { littleStream.Write(request.RequestGuid.ToByteArray()); var dt = DateTime.ParseExact( request.SentTimeString, DateTimeStringFormat20151004, CultureInfo.InvariantCulture ); littleStream.Write(dt.Ticks); littleStream.Write(request.WalletFromGuid.ToByteArray()); littleStream.Write(request.WalletToGuid.ToByteArray()); littleStream.Write(request.Amount); littleStream.Write(request.AnonymousTransfer); littleStream.Write(request.CommentBytes); littleStream.Write(request.MaxFee); } return new HMACSHA256(hmacKey).ComputeHash(ms.ToArray()); } }