static async Task ReadPipeAsync(PipeReader reader, CsvWriter csvWriter, Mapper mapper) { while (true) { var result = await reader.ReadAsync(); ReadOnlySequence <byte> buffer = result.Buffer; while (TryReadCarUpdateDatagram(ref buffer, out var completeDatagram)) { var carData = StructSerializer .Deserialize <CarUpdateDatagram>(completeDatagram.ToArray(), 0); var carModel = mapper.Map <CarStateModel>(carData); csvWriter.NextRecord(); csvWriter.WriteRecord(carModel); } reader.AdvanceTo(buffer.Start, buffer.End); if (result.IsCompleted) { break; } } await reader.CompleteAsync(); }
protected override void Write(IFileWriter dataWriter, DataChunk chunk) { var prefixSize = StructSerializer.GetSize <GzipChunkPrefix>(); using (MemoryStream memoryStream = new MemoryStream(prefixSize + chunk.Data.Length)) { using (GZipStream compressionStream = new GZipStream(memoryStream, CompressionMode.Compress, leaveOpen: true)) { memoryStream.Position = prefixSize; compressionStream.Write(chunk.Data, 0, chunk.Data.Length); } var prefix = new GzipChunkPrefix() { ChunkSize = chunk.Data.Length, Offset = chunk.Offset, GzipDataSize = (int)memoryStream.Length - prefixSize }; memoryStream.Position = 0; var prefixBytes = StructSerializer.Serialize(prefix); memoryStream.Write(prefixBytes, 0, prefixBytes.Length); memoryStream.Capacity = (int)memoryStream.Length; var compressedData = memoryStream.GetBuffer(); var offset = Interlocked.Add(ref _writeOffset, compressedData.Length) - compressedData.Length; dataWriter.WriteChunk(offset, compressedData); } }
public void TestOnlyAByte() { var obj = new OnlyAByte(0xab); var onlyAByteSerializer = new StructSerializer(new BaseSerializer[] { new ByteSerializer(obj.F1) }); var expected = new byte[] { 0xab }; Assert.Equal(expected, onlyAByteSerializer.Serialize()); }
/// <summary> /// Converts the struct to a memory stream in host-endian format (little-endian on PCs). /// </summary> /// <typeparam name="T"></typeparam> /// <param name="source">The structure.</param> /// <returns></returns> public static MemoryStream ToStream <T>([NotNull] this T source) where T : struct { source.ThrowIfNull(nameof(source)); var ms = new MemoryStream(); StructSerializer.Serialize(ms, source); return(ms); }
public void TestByteAndUInt32() { var obj = new ByteAndUInt32() { F1 = 0xab, F2 = 0x010203, }; var byteAndUInt32Serializer = new StructSerializer(new BaseSerializer[] { new ByteSerializer(obj.F1), new UInt32Serializer(obj.F2) }); byte[] expected = new byte[] { 0xab, 0x03, 0x02, 0x01, 0x00 }; Assert.Equal(expected, byteAndUInt32Serializer.Serialize()); }
public static IAxSerializer WriteStruct <T>(this IAxSerializer s, ref T source) where T : struct { Delegate @delegate; bool flag = !Delegates.TryGetValue(typeof(T), out @delegate); if (flag) { @delegate = Serializer.GetDynamicSerializer(typeof(T)).CreateDelegate(typeof(StructSerializer <T>)); } StructSerializer <T> structSerializer = (StructSerializer <T>)@delegate; structSerializer(s, ref source); return(s); }
public void TestReadStructArray() { var item1 = new CachedFileHeaderStruct { lenPath = 1 }; var serializer = new StructSerializer <CachedFileHeaderStruct>(); byte[] bytes = serializer.ToByteArray(item1); Assert.AreEqual(Marshal.SizeOf <CachedFileHeaderStruct>(), bytes.Length); var roundTrip = serializer.FromByteArray(bytes); Assert.AreEqual(item1, roundTrip); }
private void _bluetooth_DataReceived(object sender, EventArgs e) { //DeviceStream stream = new DeviceStream(_bluetooth); //Message message = await Transport.Read<Message>(stream); byte[] buffer = _bluetooth.ReadAll(); MessageHeader header = StructSerializer.DeserializeStruct <MessageHeader>(buffer); if (header.Type == MessageType.Command) { CommandMessage command = StructSerializer.DeserializeStruct <CommandMessage>(buffer); Console.WriteLine("command {0} = {1},{2}", command.Device.Hash, command.Device.IValue, command.Device.DValue); //IComponent component = _components.SingleOrDefault(i => i.Name) } }
static YamlObjectSerializer() { _structSerializer = new StructSerializer(); _typeSerializers = new Dictionary <Type, TypeSerializer> { { typeof(Color), new ColorSerializer() }, { typeof(Vector2), new Vector2Serializer() }, { typeof(Angle), new AngleSerializer() }, { typeof(Box2), new Box2Serializer() }, { typeof(ResourcePath), new ResourcePathSerializer() }, { typeof(GridId), new GridIdSerializer() }, { typeof(MapId), new MapIdSerializer() }, { typeof(SpriteSpecifier), new SpriteSpecifierSerializer() }, }; }
public static CacheHeaderStruct Read(Stream stream) { StructSerializer <CacheHeaderStruct> minimumStructSerializer = GetStructSerializer(CacheFormatVersion.Two); stream.Seek(-minimumStructSerializer.ItemSizeOnDisk, SeekOrigin.End); CacheHeaderStruct minimumStruct = minimumStructSerializer.ReadArray(stream, 1)[0]; StructSerializer <CacheHeaderStruct> actualStructSerializer = GetStructSerializer(minimumStruct.formatVersion); if (actualStructSerializer.ItemSizeOnDisk == minimumStructSerializer.ItemSizeOnDisk) { return(minimumStruct); } stream.Seek(-actualStructSerializer.ItemSizeOnDisk, SeekOrigin.End); return(actualStructSerializer.ReadArray(stream, 1)[0]); }
public void TestShorterSizeOnDisk() { var item1 = new CachedFileHeaderStruct { modified = 1, lenInstrumentInfo = 100, }; var serializer = new StructSerializer <CachedFileHeaderStruct>() { ItemSizeOnDisk = 8 }; byte[] bytes = serializer.ResizeByteArray(serializer.ToByteArray(item1), 8); Assert.AreEqual(8, bytes.Length); var roundTrip = serializer.FromByteArray(bytes); Assert.AreEqual(1, roundTrip.modified); Assert.AreEqual(0, roundTrip.lenInstrumentInfo); }
protected override DataChunk Read(IFileReader dataReader) { long offset; GzipChunkPrefix prefix; DataChunk dataChunk = null; lock (_locker) { if (_readOffset >= dataReader.Size) { return(null); } var prefixSize = StructSerializer.GetSize <GzipChunkPrefix>(); var prefixBytes = dataReader.ReadChunk(_readOffset, prefixSize); prefix = StructSerializer.Deserialize <GzipChunkPrefix>(prefixBytes); offset = _readOffset + prefixSize; _readOffset = offset + prefix.GzipDataSize; } var decompressedData = new byte[prefix.ChunkSize]; var data = dataReader.ReadChunk(offset, prefix.GzipDataSize); using (MemoryStream memoryStream = new MemoryStream(data)) { using (GZipStream decompressionStream = new GZipStream(memoryStream, CompressionMode.Decompress, leaveOpen: true)) { var decompressedDataSize = decompressionStream.Read(decompressedData, 0, prefix.ChunkSize); if (decompressedDataSize != prefix.ChunkSize) { Console.WriteLine("The specified compressed file is malformed."); } } dataChunk = new DataChunk(prefix.Offset, decompressedData); } return(dataChunk); }
public void Dispatch(DeviceLookup lookup) { //Update values DateTime now = DateTime.Now; for (int i = 0; i < _config.Count; i++) { int messageIndex = i / TelemetryMessage.EntryLength; int entryIndex = i % TelemetryMessage.EntryLength; DeviceValue entry = _messages[messageIndex].Devices[entryIndex]; object value = lookup[entry.Hash].Get(); if (lookup[entry.Hash].Property.PropertyType == typeof(Int32)) { _messages[messageIndex].Devices[entryIndex].IValue = (Int32)value; } else if (lookup[entry.Hash].Property.PropertyType == typeof(float)) { _messages[messageIndex].Devices[entryIndex].DValue = (float)value; } else { Console.WriteLine("Unknown Type: {0}", lookup[entry.Hash].Property.PropertyType); } } //Send packets foreach (TelemetryMessage message in _messages) { //var m = message; //m.Header.DateTime = now; //Send telemetry byte[] buffer = StructSerializer.Serialize(message); _stream.Write(buffer); } }
/// <summary> /// Convert the bytes to a structure in host-endian format (little-endian on PCs). /// To use with big-endian data, reverse all of the data bytes and create a struct that is in the reverse order of the data. /// </summary> /// <typeparam name="T">The structure's type</typeparam> /// <param name="source">The buffer.</param> /// <returns></returns> public static T ToStruct <T>([NotNull] this byte[] source) where T : struct => StructSerializer.Deserialize <T>(source.GetOrThrowIfNull(nameof(source)));
static async Task Main(string[] args) { // udp server configuration var serverIpAddress = IPAddress.Parse("192.168.1.53"); var serverPort = 9996; var serverEndpoint = new IPEndPoint(serverIpAddress, serverPort); // automapper initialization for mapping interop Datagrams => Models // NTS: Install-Package AutoMapper.Extensions.Microsoft.DependencyInjection MapperConfiguration config = new MapperConfiguration( cfg => { cfg.CreateMap <HandshakeResponseDatagram, HandshakeResponseModel>(); cfg.CreateMap <CarUpdateDatagram, CarStateModel>(); } ); var mapper = new Mapper(config); var handshakeRequest = new TelemetryServerConfigurationDatagram() { identifier = PlatformType.Web, version = 1, operationId = OperationType.Handshake }; // serialize request var requestByteArray = StructSerializer.Serialize(handshakeRequest); // send request and block for response using var client = new UdpClient(); client.Connect(serverEndpoint); client.Send(requestByteArray, Marshal.SizeOf(typeof(TelemetryServerConfigurationDatagram))); var responseByteArray = client.Receive(ref serverEndpoint); // deserialize and map to model var handshakeResponse = StructSerializer.Deserialize <HandshakeResponseDatagram>(responseByteArray, 0); var handshakeOutput = mapper.Map <HandshakeResponseModel>(handshakeResponse); // print result of handshake Console.WriteLine(handshakeOutput); var updateRequest = new TelemetryServerConfigurationDatagram() { identifier = PlatformType.Web, operationId = OperationType.SubscriberUpdate, version = 1 }; requestByteArray = StructSerializer.Serialize(updateRequest); await client.SendAsync(requestByteArray, Marshal.SizeOf(typeof(TelemetryServerConfigurationDatagram))); var path = $"telemetry/" + $"{handshakeOutput.DriverName}/" + $"{handshakeOutput.TrackName}/" + $"{handshakeOutput.CarName}/"; if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } using var streamWriter = new StreamWriter($"{path}/{DateTime.Now.ToFileTime()}.csv"); using var csvWriter = new CsvWriter(streamWriter, CultureInfo.InvariantCulture); csvWriter.WriteHeader(typeof(CarStateModel)); Console.CancelKeyPress += (sender, e) => { csvWriter.Flush(); streamWriter.Close(); csvWriter.Dispose(); streamWriter.Dispose(); var disconnect = new TelemetryServerConfigurationDatagram() { identifier = PlatformType.Web, operationId = OperationType.Dismiss, version = 1 }; requestByteArray = StructSerializer.Serialize(disconnect); client.Send(requestByteArray, Marshal.SizeOf(typeof(TelemetryServerConfigurationDatagram))); Console.WriteLine("Exiting Gracefully..."); Environment.Exit(0); }; await ProcessSubscriberUpdates(client, csvWriter, mapper); }
public Eeprom() { this.lockSlim = new ReaderWriterLockSlim(); this.byteEeprom = StructSerializer.StructureToByteArray(this.eeprom); }
/// <summary> /// Converts the struct to a byte array in host-endian format (little-endian on PCs). /// </summary> /// <typeparam name="T"></typeparam> /// <param name="source">The structure.</param> /// <returns></returns> public static byte[] ToBytes <T>([NotNull] this T source) where T : struct => StructSerializer.Serialize(source);
static void TestASyncMessage(int count) { Console.Write("Please input serialize type:(0:none, 1:bin, 2:xml, 3:json, 4: simplebin, 5: struct, 6: customer)"); string strSerializeType = Console.ReadLine(); int serializeType = 0; int.TryParse(strSerializeType, out serializeType); ISerialize iSerializer = null; ISerialize <StructMessage> iStructMessageSerializer = null; ISerialize <TestMessage> iTestMessageSerializer = null; switch (serializeType) { case 0: strSerializeType = "none"; break; case 1: strSerializeType = "bin"; iSerializer = new BinSerializer(); break; case 2: strSerializeType = "xml"; iSerializer = new XMLSerializer(typeof(TestMessage)); break; case 3: strSerializeType = "json"; iSerializer = new JsonSerializer(typeof(TestMessage)); break; case 4: iSerializer = new SimpleBinSerializer(typeof(TestMessage)); strSerializeType = "simplebin"; break; case 5: iStructMessageSerializer = new StructSerializer <StructMessage>(); strSerializeType = "struct"; break; case 6: iTestMessageSerializer = new TestMessageSerializer(); strSerializeType = "customer"; break; default: serializeType = 0; strSerializeType = "none"; break; } Console.WriteLine("Serialize type is {0}", strSerializeType); SingleConnectionCable client = new SingleConnectionCable(new IPEndPoint(IPAddress.Parse(_IPAddress), 2500), 7); client.ReceiveEventHandler += new EventHandler <ReceiveEventArgs>(ReceiveEventHandler); client.ErrorEventHandler += new EventHandler <ErrorEventArgs>(ErrorEventHandler); client.RemoteDisconnected += new EventHandler <DisconnectEventArgs>(DisconnectEventHandler); try { client.Connect(); Stopwatch sw = new Stopwatch(); Console.WriteLine("Test async message"); if (serializeType == 0) { sw.Start(); try { for (int i = 0; i < count; i++) { client.AsyncSend(10, buf); } } catch (Exception e) { Console.WriteLine(e); } sw.Stop(); Console.WriteLine("Finished. Elapse : {0} ms", sw.ElapsedMilliseconds); } else { TestMessage testMessage = new TestMessage() { Id = 1001, Name = "0123456789", Data = new byte[buf.Length] }; StructMessage structMessage = new StructMessage() { Id = 1001, Name = "0123456789", //Url = "http://www.google.com", //Site = "google.com", Data = new byte[4] }; for (int i = 0; i < testMessage.Data.Length; i++) { testMessage.Data[i] = (byte)i; } for (int i = 0; i < structMessage.Data.Length; i++) { structMessage.Data[i] = (byte)i; } sw.Start(); if (serializeType == 5) { try { for (int i = 0; i < count; i++) { client.AsyncSend <StructMessage>((UInt32)(20 + serializeType), ref structMessage, iStructMessageSerializer); } } catch (Exception e) { Console.WriteLine(e); } } else if (serializeType == 6) { try { for (int i = 0; i < count; i++) { client.AsyncSend <TestMessage>((UInt32)(20 + serializeType), ref testMessage, iTestMessageSerializer); } } catch (Exception e) { Console.WriteLine(e); } } else { try { for (int i = 0; i < count; i++) { client.AsyncSend((UInt32)(20 + serializeType), testMessage, iSerializer); } } catch (Exception e) { Console.WriteLine(e); } } sw.Stop(); Console.WriteLine("Finished. Elapse : {0} ms", sw.ElapsedMilliseconds); } } catch (Exception e) { Console.WriteLine(e); } finally { client.Close(); } }
private async Task ListenAsync() { uint headerSize = (uint)Marshal.SizeOf(typeof(MessageHeader)); byte[] headerBuffer = new byte[headerSize]; DataReader reader = new DataReader(_stream.InputStream); while (true) { await reader.LoadAsync(headerSize); reader.ReadBytes(headerBuffer); MessageHeader header = StructSerializer.DeserializeStruct <MessageHeader>(headerBuffer); if (header.Type == MessageType.Telemetry) { uint telemetrySize = (uint)Marshal.SizeOf(typeof(TelemetryMessage)); byte[] telemetryBuffer = new byte[telemetrySize - headerSize]; await reader.LoadAsync(telemetrySize - headerSize); reader.ReadBytes(telemetryBuffer); var z = new byte[headerBuffer.Length + telemetryBuffer.Length]; headerBuffer.CopyTo(z, 0); telemetryBuffer.CopyTo(z, headerBuffer.Length); TelemetryMessage telemetry = StructSerializer.DeserializeStruct <TelemetryMessage>(z); CurrentValues.Update(telemetry); Debug.WriteLine("Telemetry"); for (int i = 0; i < TelemetryMessage.EntryLength; i++) { Debug.WriteLine(" {0} = {1},{2}", telemetry.Devices[i].Hash, telemetry.Devices[i].IValue, telemetry.Devices[i].DValue); } Debug.WriteLine(""); for (int i = 0; i < TelemetryMessage.EntryLength; i++) { if (telemetry.Devices[i].Hash == 0) { continue; } //If we are not watching this hash, ignore it if (!_telemetry.ContainsKey(telemetry.Devices[i].Hash)) { continue; } ObservableCollection <Data> collection = _telemetry[telemetry.Devices[i].Hash]; object value; TypeCode type = _telemetryHashToType[telemetry.Devices[i].Hash]; switch (type) { case TypeCode.Int32: value = telemetry.Devices[i].IValue; break; case TypeCode.Single: value = telemetry.Devices[i].DValue; break; default: throw new NotImplementedException(); } Data data = new Data { DateTime = DateTime.Now, Value = value }; CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { collection.Add(data); }); } } } }