/// <summary>
        /// Deserialize an object graph from the speciied <paramref name="stream"/>.
        /// </summary>
        /// <param name="stream">The <see cref="Stream"/> from which to deserialize an object graph.</param>
        /// <param name="type">The <see cref="Type"/> of object being deserialized.</param>
        public Object Deserialize(Stream stream, Type type)
        {
            Verify.NotNull(stream, nameof(stream));

            using (var gzipStream = new GZipStream(stream, CompressionMode.Decompress))
                return(serializer.Deserialize(gzipStream, type));
        }
            private Message <String> ReceiveMessage()
            {
                var message = testQueue.Receive(TimeSpan.FromSeconds(1));

                Assert.NotNull(message);

                return(serializer.Deserialize <Message <String> >(message.BodyStream));
            }
        /// <summary>
        /// Deserializes a binary field in to an object graph.
        /// </summary>
        /// <param name="serializer">The <see cref="ISerializeObjects"/> implementation being extended.</param>
        /// <param name="buffer">The binary data to be deserialized in to an object graph.</param>
        public static T Deserialize <T>(this ISerializeObjects serializer, Byte[] buffer)
        {
            using (var stream = new MemoryStream(buffer, writable: false))
            {
                var result = serializer.Deserialize <T>(stream);

                return(result);
            }
        }
        /// <summary>
        /// Deserializes a binary field in to an object graph.
        /// </summary>
        /// <param name="serializer">The <see cref="ISerializeObjects"/> implementation being extended.</param>
        /// <param name="buffer">The binary data to be deserialized in to an object graph.</param>
        /// <param name="type">The <see cref="Type"/> of object being deserialized.</param>
        public static Object Deserialize(this ISerializeObjects serializer, Byte[] buffer, Type type)
        {
            using (var stream = new MemoryStream(buffer, writable: false))
            {
                var result = serializer.Deserialize(stream, type);

                return(result);
            }
        }
        /// <summary>
        /// Creates a new <see cref="Commit"/>.
        /// </summary>
        /// <param name="record">The record from which to create the new <see cref="Commit"/>.</param>
        private Commit CreateCommit(IDataRecord record)
        {
            var id            = record.GetInt64(Column.Id);
            var timestamp     = record.GetDateTime(Column.Timestamp);
            var correlationId = record.GetGuid(Column.CorrelationId);
            var streamId      = record.GetGuid(Column.StreamId);
            var version       = record.GetInt32(Column.Version);
            var data          = serializer.Deserialize <CommitData>(record.GetBytes(Column.Data));

            return(new Commit(id, timestamp, correlationId, streamId, version, data.Headers, data.Events));
        }
Exemple #6
0
        /// <summary>
        /// Creates a new <see cref="Saga"/>.
        /// </summary>
        /// <param name="record">The record from which to create the new <see cref="Saga"/>.</param>
        private Saga CreateSaga(IDataRecord record)
        {
            var id      = record.GetGuid(Column.Id);
            var version = record.GetInt32(Column.Version);
            var timeout = record.GetNullableDateTime(Column.Timeout);
            var saga    = serializer.Deserialize <Saga>(record.GetBytes(Column.State));

            saga.CorrelationId = id;
            saga.Version       = version;
            saga.Timeout       = timeout;

            return(saga);
        }
        /// <summary>
        /// Deserialize an object graph from the speciied <paramref name="stream"/>.
        /// </summary>
        /// <param name="serializer">The <see cref="ISerializeObjects"/> implementation being extended.</param>
        /// <param name="stream">The <see cref="Stream"/> from which to deserialize an object graph.</param>
        public static T Deserialize <T>(this ISerializeObjects serializer, Stream stream)
        {
            Verify.NotNull(serializer, nameof(serializer));

            return((T)serializer.Deserialize(stream, typeof(T)));
        }
 /// <summary>
 /// Creates a new <see cref="Snapshot"/>.
 /// </summary>
 /// <param name="type">The snapshot type.</param>
 /// <param name="record">The record from which to create the new <see cref="Snapshot"/>.</param>
 private Snapshot CreateSnapshot(Type type, IDataRecord record)
 {
     return(new Snapshot(record.GetGuid(Column.StreamId), record.GetInt32(Column.Version), serializer.Deserialize(record.GetBytes(Column.State), type)));
 }