public override object Deserialize(string serialized) { var b = Convert.FromBase64String(serialized); using (var stream = new MemoryStream(b)) { stream.Seek(0, SeekOrigin.Begin); return(_serializer.Deserialize(stream)); } }
public static T FromBytes(byte[] bytes) { using (var buffer = new MemoryStream(bytes)) { return(ser.Deserialize(buffer)); } }
private IEnumerable <object> ReadObjects <T>(StreamReader sr, IAvroSerializer <T> avroSerializer, Func <object, bool?> filterFunc = null) { while (true) { object obj = null; try { obj = avroSerializer.Deserialize(sr.BaseStream); if (IsDynamicType) { obj = new ChoDynamicObject(obj as Dictionary <string, object>); } } catch (System.OverflowException) { break; } catch (SerializationException sEx) { if (sEx.Message.StartsWith("Invalid integer value in the input stream")) { break; } throw; } yield return(obj); } }
/// <summary> /// Generate and store the metadata necessary to serialze and deserialize a specific message type. /// </summary> /// <typeparam name="TMessage">The class type of the message being registered.</typeparam> internal void Register <TMessage>() { Logr.Log(Level.Info, "Registering message type: {0} {1}", typeof(TMessage).FullName, typeof(TMessage).Name); IAvroSerializer <TMessage> messageSerializer = AvroSerializer.Create <TMessage>(); Serialize serialize = (MemoryStream stream, object message) => { messageSerializer.Serialize(stream, (TMessage)message); }; serializeMap.Add(typeof(TMessage).Name, serialize); Deserialize deserialize = (MemoryStream stream, object observer, long sequence) => { TMessage message = messageSerializer.Deserialize(stream); var msgObserver = observer as IObserver <IMessageInstance <TMessage> >; if (msgObserver != null) { msgObserver.OnNext(new MessageInstance <TMessage>(sequence, message)); } else { Logr.Log(Level.Warning, "Unhandled message received: {0}", message); } }; deserializeMap.Add(typeof(TMessage).Name, deserialize); }
public static DefinedRuntimes FromBytes(byte[] serializedData) { using (Stream stream = new MemoryStream(serializedData)) { return(Serializer.Deserialize(stream)); } }
public T Deserialize(byte[] data) { using (var buffer = new MemoryStream(data)) { return(_serializer.Deserialize(buffer)); } }
/// <summary> /// Read a message from the input byte array. /// </summary> /// <param name="data">Byte array containing a header message and message to be deserialized.</param> /// <param name="observer">An object which implements the IObserver<> /// interface for the message being deserialized.</param> public void Read <T>(byte[] data, IObserver <IMessageInstance <T> > observer) { try { using (MemoryStream stream = new MemoryStream(data)) { Header head = headerSerializer.Deserialize(stream); Deserialize deserialize; if (deserializeMap.TryGetValue(head.className, out deserialize)) { deserialize(stream, observer, head.sequence); } else { throw new SeializationException( "Request to deserialize unknown message type: " + head.className); } } } catch (Exception e) { Logr.Log(Level.Error, "Failure reading message.", e); throw e; } }
/// <summary> /// Read a message from the input byte array. /// </summary> /// <param name="data">Byte array containing a header message and message to be deserialized.</param> /// <param name="observer">An object which implements the IObserver<> /// interface for the message being deserialized.</param> public void Read(byte[] data, object observer) { try { using (MemoryStream stream = new MemoryStream(data)) { Header head = _headerSerializer.Deserialize(stream); Log.Log(Level.Verbose, "Message header {0}", head); Deserialize deserialize; if (_deserializeMap.TryGetValue(head.className, out deserialize)) { deserialize(stream, observer, head.sequence); } else { throw new SeializationException( "Request to deserialize unknown message type: " + head.className); } } } catch (Exception e) { Log.Log(Level.Error, "Failure reading message.", e); throw e; } }
public T Deserialize(byte[] arrayToDeserialize) { using (var memStream = new MemoryStream(arrayToDeserialize)) { return(avroSerializer.Deserialize(memStream)); } }
/// <summary> /// Converts a byte array to an object using Avro deserialization. /// </summary> /// <param name="data">The byte array to deserialize</param> /// <returns>The deserialized object</returns> public static T AvroDeserialize <T>(byte[] data) { IAvroSerializer <T> deserializer = AvroSerializer.Create <T>(); using (MemoryStream stream = new MemoryStream(data)) { return(deserializer.Deserialize(stream)); } }
public T Deserialize(byte[] data) { var buffer = data.Skip(5).ToArray(); using (var memoryStream = new MemoryStream(buffer)) { return(avroSerializer.Deserialize(memoryStream)); } }
public TestKafkaModel Deserialize(byte[] data) { try { using (var memoryStream = new MemoryStream(data)) { var result = (AvroRecord)avroSerializer.Deserialize(memoryStream); return(new TestKafkaModel { Timestamp = result.GetField <long>("timestamp"), Payload = result.GetField <byte[]>("payload") }); } } catch (Exception e) { Console.WriteLine(e); throw; } }
public Tuple <K, V> ConsumeNext() { var next = ConsumeInternal(); using (var keyStream = new MemoryStream(next.Key)) using (var keyReader = new BinaryReader(keyStream)) using (var valueStream = new MemoryStream(next.Payload)) using (var valueReader = new BinaryReader(valueStream)) { keyReader.ReadByte(); var keySchemaId = keyReader.ReadInt32(); var key = _keySerde.Deserialize(keyStream); valueReader.ReadByte(); var valueSchemaId = valueReader.ReadInt32(); var value = _valueSerde.Deserialize(valueStream); return(new Tuple <K, V>(key, value)); } }
public override Catalog Deserialize(Stream stream) { return(serializer.Deserialize(stream)); }
private object Deserialize(Stream stream) { return(_serializer.Deserialize(stream)); }