public void PlainObjectsWithNoInheritance() { const PrefixStyle prefix = PrefixStyle.Base128; const string memberName = "Id"; using (var ms = new MemoryStream()) { var items = new List <PlainObject>(); for (var i = 0; i < 10; i++) { items.Add(PlainObject.WithId(i)); } foreach (var item in items) { _model.SerializeWithLengthPrefix(ms, item, prefix); } var builder = new ProjectionTypeBuilder(_model); var type = builder.GetTypeForProjection(typeof(PlainObject), typeof(PlainObject).GetMember(memberName)); ms.Seek(0, SeekOrigin.Begin); var deserializedItems = _model.DeserializeItems(ms, type, prefix, 0, null).Cast <object>().ToArray(); Assert.AreEqual(items.Count, deserializedItems.Length); var fi = (FieldInfo)type.GetMember(memberName)[0]; for (var i = 0; i < items.Count; i++) { Assert.AreEqual(items[i].Id, (int)fi.GetValue(deserializedItems[i])); } } }
/// <summary> /// Initializes this target. /// </summary> public override void Initialize() { _currentEntities.Clear(); // write the mandatory header. _buffer.Seek(0, SeekOrigin.Begin); // create header block. var blockHeader = new HeaderBlock(); blockHeader.required_features.Add("OsmSchema-V0.6"); blockHeader.required_features.Add("DenseNodes"); _runtimeTypeModel.Serialize(_buffer, blockHeader); var blockHeaderData = _buffer.ToArray(); _buffer.SetLength(0); // create blob. var blob = new Blob(); blob.raw = blockHeaderData; _runtimeTypeModel.Serialize(_buffer, blob); // create blobheader. var blobHeader = new BlobHeader(); blobHeader.datasize = (int)_buffer.Length; blobHeader.indexdata = null; blobHeader.type = Encoder.OSMHeader; _runtimeTypeModel.SerializeWithLengthPrefix(_stream, blobHeader, _blobHeaderType, ProtoBuf.PrefixStyle.Fixed32BigEndian, 0); // flush to stream. _buffer.Seek(0, SeekOrigin.Begin); _buffer.CopyTo(_stream); }
public void SetUp() { _stream = new MemoryStream(); for (var i = 0; i < RepetetionCount; i++) { _model.SerializeWithLengthPrefix(_stream, Employee.Create(2 * i, "Test" + i, "City" + i, "Street+i"), Prefix); _model.SerializeWithLengthPrefix(_stream, Employee.CreateManager(2 * i + 1, "Test" + i, "City" + i, "Street+i"), Prefix); } _stream.Seek(0, SeekOrigin.Begin); }
/// <summary> /// Initializes this target. /// </summary> public override void Initialize() { _currentEntities.Clear(); // write the mandatory header. _buffer.Seek(0, SeekOrigin.Begin); // create header block. var blockHeader = new HeaderBlock(); blockHeader.required_features.Add("OsmSchema-V0.6"); blockHeader.required_features.Add("DenseNodes"); _runtimeTypeModel.Serialize(_buffer, blockHeader); var blockHeaderData = _buffer.ToArray(); _buffer.SetLength(0); // create blob. var blob = new Blob(); if (_compress) { using (var target = new MemoryStream()) { using (var source = new MemoryStream(blockHeaderData)) using (var deflate = new DeflaterOutputStream(target)) { source.CopyTo(deflate); } blob.zlib_data = target.ToArray(); } } else { blob.raw = blockHeaderData; } _runtimeTypeModel.Serialize(_buffer, blob); // create blobheader. var blobHeader = new BlobHeader(); blobHeader.datasize = (int)_buffer.Length; blobHeader.indexdata = null; blobHeader.type = Encoder.OSMHeader; _runtimeTypeModel.SerializeWithLengthPrefix(_stream, blobHeader, _blobHeaderType, ProtoBuf.PrefixStyle.Fixed32BigEndian, 0); // flush to stream. _buffer.Seek(0, SeekOrigin.Begin); _buffer.CopyTo(_stream); }
/// <summary> /// Writes a protocol-buffer representation of the given instance to the supplied stream, /// with a length-prefix. This is useful for socket programming, /// as DeserializeWithLengthPrefix/MergeWithLengthPrefix can be used to read the single object back /// from an ongoing stream. /// </summary> /// <typeparam name="T">The type being serialized.</typeparam> /// <param name="instance">The existing instance to be serialized (cannot be null).</param> /// <param name="style">How to encode the length prefix.</param> /// <param name="destination">The destination stream to write to.</param> /// <param name="fieldNumber">The tag used as a prefix to each record (only used with base-128 style prefixes).</param> public static void SerializeWithLengthPrefix <T>(Stream destination, T instance, PrefixStyle style, int fieldNumber) { RuntimeTypeModel model = RuntimeTypeModel.Default; model.SerializeWithLengthPrefix(destination, instance, model.MapType(typeof(T)), style, fieldNumber); }
public PerformanceTests() { _model = TypeModel.Create(); _model.Add(typeof(Event), true); _stream = new MemoryStream(); for (var i = 0; i < 1000 * 1000; i++) { var id = Guid.NewGuid(); var item = new OrderPlacedEvent(id, "Ordered by customer number" + i.ToString(CultureInfo.InvariantCulture), new[] { new OrderItem("Test product", i) }); var shipment = new OrderShippedEvent(id, DateTime.Now); _model.SerializeWithLengthPrefix(_stream, item, typeof(Event), Prefix, 0); _model.SerializeWithLengthPrefix(_stream, shipment, typeof(Event), Prefix, 0); } }
public void SerializeWithLengthPrefix <T>(IEnumerable <T> content, string path) where T : new() { using (var fileStream = File.Open(path, FileMode.Create)) { foreach (var item in content) { _model.SerializeWithLengthPrefix(fileStream, item, typeof(T), PrefixStyle.Base128, 1); } } }
public void WriteSpatialRecords(string path, IEnumerable <SpatialRecord> spatialRecords) { using (var fileStream = File.Open(path, FileMode.Create)) { foreach (var spatialRecord in spatialRecords) { _model.SerializeWithLengthPrefix(fileStream, spatialRecord, typeof(SpatialRecord), PrefixStyle.Base128, 1); } } }
/// <summary> /// Writes a protocol-buffer representation of the given instance to the supplied stream, /// with a length-prefix. This is useful for socket programming, /// as DeserializeWithLengthPrefix/MergeWithLengthPrefix can be used to read the single object back /// from an ongoing stream. /// </summary> /// <param name="instance">The existing instance to be serialized (cannot be null).</param> /// <param name="style">How to encode the length prefix.</param> /// <param name="destination">The destination stream to write to.</param> /// <param name="fieldNumber">The tag used as a prefix to each record (only used with base-128 style prefixes).</param> public static void SerializeWithLengthPrefix(Stream destination, object instance, PrefixStyle style, int fieldNumber) { if (instance == null) { throw new ArgumentNullException("instance"); } RuntimeTypeModel model = RuntimeTypeModel.Default; model.SerializeWithLengthPrefix(destination, instance, model.MapType(instance.GetType()), style, fieldNumber); }
/// <summary> /// Serializes the object to string. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="data"></param> /// <returns></returns> public static byte[] Serialize <T>(T data) { try { using (MemoryStream outputStream = new MemoryStream()) { TypeModel.SerializeWithLengthPrefix(outputStream, data, typeof(T), ProtoBuf.PrefixStyle.Base128, 0); return(outputStream.GetBuffer()); } } catch (Exception e) { MasterLog.DebugWriteLine(e.Message); return(null); } }
static void TestClone(string fileName, int size, RuntimeTypeModel m) { using (var stream = new FileStream(fileName, FileMode.Create)) { stream.SetLength(0); GC.GetTotalMemory(true); m.SerializeWithLengthPrefix(stream, new Wrapper() { Count = size }, typeof(Wrapper), PrefixStyle.Base128, 0); Assert.That(stream.Length, Is.AtLeast(size)); Assert.That(stream.Length, Is.LessThan(size + 10000)); stream.Flush(true); GC.GetTotalMemory(true); stream.Position = 0; var w = (Wrapper)m.DeserializeWithLengthPrefix(stream, null, typeof(Wrapper), PrefixStyle.Base128, 0); Assert.That(w.Count, Is.EqualTo(size)); Assert.That(stream.Position, Is.EqualTo(stream.Length)); } }
/// <summary> /// Serializes an object, or graph of objects with the given root to the provided stream. /// </summary> /// <param name="stream">The stream where the formatter puts the serialized data. This stream can /// reference a variety of backing stores (such as files, network, memory, and so on).</param> /// <param name="graph">The object, or root of the object graph, to serialize. /// All child objects of this root object are automatically serialized.</param> public void Serialize(Stream stream, object graph) { Ensure.NotNull(stream, "stream"); Ensure.NotNull(graph, "graph"); if (IncludeTypeName) { new BinaryWriter(stream, Encoding.UTF8) .Write(graph.GetType().AssemblyQualifiedName); } if (UseLengthPrefix) { _typeModel.SerializeWithLengthPrefix(stream, graph, graph.GetType(), PrefixStyle.Base128, 0); } else { _typeModel.Serialize(stream, graph); } }
public void Serialize(Stream stream, object value, Type type) { _runtime.SerializeWithLengthPrefix(stream, value, type, PrefixStyle.Fixed32, 0); }
public void Serialize(Stream stream, object o) { model.SerializeWithLengthPrefix(stream, o, o.GetType(), PrefixStyle.Base128, 0); }
public void Serialize(object value, Stream stream) { _runtime.SerializeWithLengthPrefix(stream, value, value.GetType(), ProtoBuf.PrefixStyle.Fixed32, 0); }
internal void Serialise(Stream stream, Type type, object obj) { Wrapped(() => _model.SerializeWithLengthPrefix(stream, obj, type, PrefixStyle.Base128, 0)); }
public static void SerializeWithLengthPrefix <T>(this RuntimeTypeModel model, Stream destination, T instance, PrefixStyle style, int fieldNumber) { model.SerializeWithLengthPrefix(destination, instance, typeof(T), style, fieldNumber); }