/// <summary> /// Read stream to the current object include the body and properties using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public void EntityRead(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } string mmsg = streamer.ReadFixedString(); if (mmsg != TcpReplyStream.MsgReplyBegin) { throw new Exception("Incorrect message format"); } m_ReplyCode = streamer.ReadValue <int>(); m_ReplyType = (TcpReplyType)streamer.ReadValue <byte>(); if (m_ReplyType == TcpReplyType.Stream) { m_ReplyStream = (NetStream)streamer.ReadValue(); } else { m_Text = streamer.ReadString(); } string endmsg = streamer.ReadFixedString(); if (endmsg != TcpReplyStream.MsgReplyEnd) { throw new Exception("Incorrect message format"); } }
/// <summary> /// Read stream to the current object include the body and properties using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public void EntityRead(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } string mmsg = streamer.ReadFixedString(); if (mmsg != MessageContext.QPRO) { throw new Exception("Incorrect message format"); } Mode = (CoverMode)streamer.ReadValue <byte>(); IsTrans = streamer.ReadValue <bool>(); MaxRetry = streamer.ReadValue <byte>(); QueueName = streamer.ReadString(); ServerPath = streamer.ReadString(); //Cover = streamer.ReadValue<QCover>(); ConnectTimeout = streamer.ReadValue <int>(); TargetPath = streamer.ReadString(); IsTopic = streamer.ReadValue <bool>(); CommitMode = (PersistCommitMode)streamer.ReadValue <byte>(); }
/// <summary> /// Serialize message as stream. /// </summary> /// <param name="writeContextType"></param> /// <returns></returns> public static NetStream Serialize(this IQueueItem message, bool writeContextType) { NetStream ns = new NetStream(); var streamer = new BinaryStreamer(ns); if (writeContextType) { streamer.WriteContextType(SerialContextType.SerialEntityType); } message.EntityWrite(ns, streamer); return(ns); }
/// <summary> /// Read stream to the current object include the body and properties using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public void EntityRead(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } HostName = streamer.ReadString(); ServerName = streamer.ReadString(); _RawHostAddress = streamer.ReadString(); _HostAddress = streamer.ReadString(); _HostProtocol = (HostProtocol)streamer.ReadValue <byte>(); }
/// <summary> /// Read stream to the current object include the body and properties using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public void EntityRead(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } Identifier = streamer.ReadString();//.ReadValue<Guid>(); ItemState = (TransItemState)streamer.ReadValue <int>(); Retry = streamer.ReadValue <int>(); ArrivedTime = streamer.ReadValue <DateTime>(); Timeout = TimeSpan.FromSeconds(streamer.ReadValue <int>()); }
/// <summary> /// Read stream to the current object include the body and properties using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public override void EntityRead(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } Version = streamer.ReadValue <int>(); var MessageState = (MessageState)streamer.ReadValue <byte>(); var MessageType = (MQTypes)streamer.ReadValue <byte>(); QCommand = (QueueCmd)streamer.ReadValue <byte>(); Priority = (Priority)streamer.ReadValue <byte>(); Identifier = streamer.ReadString();//.ReadValue<Guid>(); var Retry = streamer.ReadValue <byte>(); var ArrivedTime = streamer.ReadValue <DateTime>(); Creation = streamer.ReadValue <DateTime>(); Modified = streamer.ReadValue <DateTime>(); var Duration = streamer.ReadValue <int>(); TransformType = (TransformType)streamer.ReadValue <byte>(); DuplexType = (DuplexTypes)streamer.ReadValue <byte>(); Expiration = streamer.ReadValue <int>(); Host = streamer.ReadString(); Label = streamer.ReadString(); Sender = streamer.ReadString(); BodyStream = (NetStream)streamer.ReadValue(); TypeName = streamer.ReadString(); /* * Version = streamer.ReadValue<int>(); * var MessageType = (MQTypes)streamer.ReadValue<byte>(); * QCommand = (QueueCmd)streamer.ReadValue<byte>(); * Priority = (Priority)streamer.ReadValue<byte>(); * Identifier = streamer.ReadString();//.ReadValue<Guid>(); * Creation = streamer.ReadValue<DateTime>(); * //TransformType = (TransformTypes)streamer.ReadValue<byte>(); * TransformType = (TransformType)streamer.ReadValue<byte>(); * DuplexType = (DuplexTypes)streamer.ReadValue<byte>(); * Expiration = streamer.ReadValue<int>(); * * Host = streamer.ReadString(); * //Sender = streamer.ReadString(); * BodyStream = (NetStream)streamer.ReadValue(); * //_TypeName = streamer.ReadString(); */ }
/// <summary> /// Read stream to the current object include the body and properties using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public void EntityRead(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } MessageState = (MessageState)streamer.ReadValue <byte>(); MessageType = (MQTypes)streamer.ReadValue <byte>(); Command = (QueueCmd)streamer.ReadValue <byte>(); Priority = (Priority)streamer.ReadValue <byte>(); Identifier = streamer.ReadString();//.ReadValue<Guid>(); Retry = streamer.ReadValue <byte>(); ArrivedTime = streamer.ReadValue <DateTime>(); //SentTime = streamer.ReadValue<DateTime>(); Modified = streamer.ReadValue <DateTime>(); Expiration = streamer.ReadValue <int>(); //MessageId = streamer.ReadValue<int>(); TransformType = (TransformTypes)streamer.ReadValue <byte>(); Destination = streamer.ReadString(); //Label = streamer.ReadString(); //Sender = streamer.ReadString(); ////Topic = streamer.ReadString(); //HeaderStream = (NetStream)streamer.ReadValue(); m_BodyStream = (NetStream)streamer.ReadValue(); //var ns = (NetStream)streamer.ReadValue(); //Body = ns.ToArray(); ItemBinary = streamer.ReadValue <byte[]>(); //var map = streamer.GetMapper(); //Console.WriteLine(map); //if (Command != QueueCmd.Ack) //{ // Formatter = (Formatters)streamer.ReadValue<int>(); // m_BodyStream = (NetStream)streamer.ReadValue(); // _TypeName = streamer.ReadString(); // Segments = streamer.ReadValue<byte>(); // //HostType = streamer.ReadValue<byte>(); // Notify = streamer.ReadString(); // //Command = streamer.ReadString(); // //IsDuplex = streamer.ReadValue<bool>(); // //HeaderStream = (GenericNameValue)streamer.ReadValue(); //} }
/// <summary> /// Write the current object include the body and properties to stream using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public void EntityWrite(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } streamer.WriteString(Identifier);//.WriteValue(Identifier); streamer.WriteValue((int)ItemState); streamer.WriteValue(Retry); streamer.WriteValue(ArrivedTime); streamer.WriteValue(Timeout); streamer.Flush(); }
/// <summary> /// Write the current object include the body and properties to stream using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public void EntityWrite(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } streamer.WriteString(HostName); streamer.WriteString(ServerName); streamer.WriteString(RawHostAddress); streamer.WriteString(HostAddress); streamer.WriteValue((byte)Protocol); streamer.Flush(); }
/* * /// <summary> * /// Release all resources. * /// </summary> * public void Dispose() * { * Dispose(true); * GC.SuppressFinalize(this); * } * bool disposed = false; * /// <summary> * /// Get indicate wether the current instance is Disposed. * /// </summary> * internal bool IsDisposed * { * get { return disposed; } * } * /// <summary> * /// Dispose. * /// </summary> * /// <param name="disposing"></param> * internal void Dispose(bool disposing) * { * if (!disposed) * { * //Command = null; * * Host = null; * } * disposed = true; * } */ #endregion #region ISerialEntity /// <summary> /// Write the current object include the body and properties to stream using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public override void EntityWrite(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } //streamer.WriteValue(ToBinary()); streamer.WriteValue(Version); streamer.WriteValue((byte)MessageState.Sending); streamer.WriteValue((byte)MessageType); streamer.WriteValue((byte)QCommand); streamer.WriteValue((byte)Priority); streamer.WriteString(Identifier); //.WriteValue(ItemId); streamer.WriteValue((byte)0); //Retry streamer.WriteValue(Modified); // ArrivedTime); streamer.WriteValue(Creation); streamer.WriteValue(Modified); streamer.WriteValue((int)0);// Duration); streamer.WriteValue((byte)TransformType); streamer.WriteValue((byte)DuplexType); streamer.WriteValue(Expiration); streamer.WriteString(Host); streamer.WriteString(Label); streamer.WriteString(Sender); streamer.WriteValue(BodyStream); streamer.WriteString(TypeName); /* * streamer.WriteValue(Version); * streamer.WriteValue((byte)MessageType); * streamer.WriteValue((byte)QCommand); * streamer.WriteValue((byte)Priority); * streamer.WriteString(Identifier);//.WriteValue(ItemId); * streamer.WriteValue(Creation); * streamer.WriteValue((byte)TransformType); * streamer.WriteValue((byte)DuplexType); * streamer.WriteValue(Expiration); * * streamer.WriteString(Host); * //streamer.WriteString(Sender); * * streamer.WriteValue(BodyStream); * //streamer.WriteString(TypeName); */ }
/* * /// <summary> * /// Write the current object include the body and properties to <see cref="ISerializerContext"/> using <see cref="SerializeInfo"/>. * /// </summary> * /// <param name="context"></param> * public void WriteContext(ISerializerContext context) * { * SerializeInfo info = new SerializeInfo(); * * info.Add("Command", (byte)Command); * info.Add("Priority", (byte)Priority); * info.Add("Host", Host); * info.Add("TransformType", (byte)TransformType); * info.Add("Creation", Creation); * context.WriteSerializeInfo(info); * } * * * /// <summary> * /// Read <see cref="ISerializerContext"/> context to the current object include the body and properties using <see cref="SerializeInfo"/>. * /// </summary> * /// <param name="context"></param> * public void ReadContext(ISerializerContext context) * { * SerializeInfo info = context.ReadSerializeInfo(); * ReadContext(info); * } * * /// <summary> * /// Read <see cref="SerializeInfo"/> context to the current object include the body and properties using <see cref="SerializeInfo"/>. * /// </summary> * /// <param name="context"></param> * void ReadContext(SerializeInfo info) * { * * Command = (QueueCmd)info.GetValue<byte>("Command"); * Priority = (Priority)info.GetValue<byte>("Priority"); * Host = info.GetValue<string>("Host"); * TransformType =(TransformTypes) info.GetValue<byte>("TransformType"); * Creation = info.GetValue<DateTime>("Creation"); * } */ #endregion public byte[] ToBinary() { byte[] binary = null; using (NetStream s = new NetStream()) { using (var strmer = new BinaryStreamer(s)) { //strmer.WriteValue(Version); //strmer.WriteValue((byte)MessageType); //strmer.WriteValue((byte)QCommand); //strmer.WriteValue((byte)Priority); //strmer.WriteString(Identifier);//.WriteValue(ItemId); //strmer.WriteValue(Creation); //strmer.WriteValue((byte)TransformType); //strmer.WriteValue((byte)DuplexType); //strmer.WriteValue(Expiration); //strmer.WriteString(Host); ////strmer.WriteString(Sender); //strmer.WriteValue(BodyStream); ////strmer.WriteString(TypeName); strmer.WriteValue(Version); strmer.WriteValue((byte)MessageState.Sending); strmer.WriteValue((byte)MessageType); strmer.WriteValue((byte)QCommand); strmer.WriteValue((byte)Priority); strmer.WriteString(Identifier); //.WriteValue(ItemId); strmer.WriteValue((byte)0); //Retry strmer.WriteValue(Modified); // ArrivedTime); strmer.WriteValue(Creation); strmer.WriteValue(Modified); strmer.WriteValue((int)0);// Duration); strmer.WriteValue((byte)TransformType); strmer.WriteValue((byte)DuplexType); strmer.WriteValue(Expiration); strmer.WriteString(Host); strmer.WriteString(Label); strmer.WriteString(Sender); strmer.WriteValue(BodyStream); strmer.WriteString(TypeName); binary = s.ToArray(); } } return(binary); }
/// <summary> /// Convert stream to json. /// </summary> /// <param name="stream"></param> /// <param name="format"></param> /// <returns></returns> public static string ToJson(NetStream stream, JsonFormat format) { using (BinaryStreamer streamer = new BinaryStreamer(stream)) { var obj = streamer.Decode(); if (obj == null) { return(null); } else { return(JsonSerializer.Serialize(obj, null, format)); } } }
/// <summary> /// Write the current object include the body and properties to stream using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public void EntityWrite(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } streamer.WriteFixedString(MessageContext.QPTR, 4); streamer.WriteValue((byte)State); streamer.WriteValue((int)Retry); streamer.WriteString(Identifier); streamer.WriteString(Host); streamer.WriteValue(ArrivedTime); streamer.WriteValue(TimeOut); //streamer.WriteString(Location); streamer.Flush(); }
/// <summary> /// Read stream to the current object include the body and properties using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public void EntityRead(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } MessageState = (MessageState)streamer.ReadValue <byte>(); Identifier = streamer.ReadString(); Creation = streamer.ReadValue <DateTime>(); Host = streamer.ReadString(); Label = streamer.ReadString(); Duration = streamer.ReadValue <int>(); Count = streamer.ReadValue <int>(); //string arrived = streamer.ReadString(); //ArrivedTime= Types.ToNullableDate(arrived); ArrivedTime = streamer.ReadValue <DateTime>(); }
/// <summary> /// Write the current object include the body and properties to stream using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public void EntityWrite(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } streamer.WriteFixedString(MessageContext.QPRO, 4); streamer.WriteValue((byte)Mode); streamer.WriteValue(IsTrans); streamer.WriteValue(MaxRetry); streamer.WriteValue(QueueName); streamer.WriteValue(ServerPath); //streamer.WriteValue(Cover); streamer.WriteValue(ConnectTimeout); streamer.WriteValue(CoverPath); streamer.Flush(); }
/// <summary> /// Write the current object include the body and properties to stream using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public void EntityWrite(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } streamer.WriteValue((byte)MessageState); streamer.WriteValue((byte)MessageType); streamer.WriteValue((byte)Command); streamer.WriteValue((byte)Priority); streamer.WriteString(Identifier);//.WriteValue(ItemId); streamer.WriteValue(Retry); streamer.WriteValue(ArrivedTime); //streamer.WriteValue(SentTime); streamer.WriteValue(Modified); streamer.WriteValue(Expiration); //streamer.WriteValue(MessageId); streamer.WriteValue((byte)TransformType); streamer.WriteString(Destination); streamer.WriteValue(BodyStream); //streamer.WriteString(Label); //streamer.WriteString(Sender); //streamer.WriteString(Topic); //streamer.WriteValue(HeaderStream); //streamer.WriteValue(new NetStream(Body)); streamer.WriteValue(ItemBinary); //if (Command != QueueCmd.Ack) //{ // streamer.WriteValue((int)Formatter); // streamer.WriteValue(BodyStream); // streamer.WriteString(TypeName); // streamer.WriteValue(Segments); // streamer.WriteString(Notify); //} streamer.Flush(); }
/// <summary> /// Write the current object include the body and properties to stream using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public void EntityWrite(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } streamer.WriteValue((byte)MessageState); streamer.WriteString(Identifier); streamer.WriteValue(Creation); streamer.WriteString(Host); streamer.WriteString(Label); streamer.WriteValue(Duration); streamer.WriteValue(Count); streamer.WriteValue(ArrivedTime); //string arrived = ArrivedTime == null || ArrivedTime.HasValue == false ? null : ArrivedTime.ToString(); //streamer.WriteString(arrived); streamer.Flush(); }
/// <summary> /// Read stream to the current object include the body and properties using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public void EntityRead(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } MessageState = (MessageState)streamer.ReadValue <byte>(); MessageType = (MQTypes)streamer.ReadValue <byte>(); Command = (QueueCmd)streamer.ReadValue <byte>(); Priority = (Priority)streamer.ReadValue <byte>(); Identifier = streamer.ReadString(); //.ReadValue<Guid>(); Retry = streamer.ReadValue <byte>(); ArrivedTime = streamer.ReadValue <DateTime>(); Creation = streamer.ReadValue <DateTime>(); Modified = streamer.ReadValue <DateTime>(); Duration = streamer.ReadValue <int>(); TransformType = (TransformTypes)streamer.ReadValue <byte>(); Host = streamer.ReadString(); Sender = streamer.ReadString(); Label = streamer.ReadString(); }
/// <summary> /// Write the current object include the body and properties to stream using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public void EntityWrite(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } streamer.WriteFixedString(TcpReplyStream.MsgReplyBegin, 4); streamer.WriteValue((int)ReplyCode); streamer.WriteValue((byte)m_ReplyType); if (m_ReplyType == TcpReplyType.Stream) { streamer.WriteValue(m_ReplyStream); } else { streamer.WriteString(m_Text); } streamer.WriteFixedString(TcpReplyStream.MsgReplyEnd, 5); streamer.Flush(); }
/// <summary> /// Read stream to the current object include the body and properties using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public void EntityRead(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } string mmsg = streamer.ReadFixedString(); if (mmsg != MessageContext.QPTR) { throw new Exception("Incorrect message format"); } m_State = (PtrState)streamer.ReadValue <byte>(); m_Retry = streamer.ReadValue <int>(); m_Identifier = streamer.ReadString(); m_Host = streamer.ReadString(); m_ArrivedTime = streamer.ReadValue <DateTime>(); m_TimeOut = streamer.ReadValue <int>(); //m_Location = streamer.ReadString(); }
/// <summary> /// Write the current object include the body and properties to stream using <see cref="IBinaryStreamer"/>, This method is a part of <see cref="ISerialEntity"/> implementation. /// </summary> /// <param name="stream"></param> /// <param name="streamer"></param> public void EntityWrite(Stream stream, IBinaryStreamer streamer) { if (streamer == null) { streamer = new BinaryStreamer(stream); } streamer.WriteValue((byte)MessageState); streamer.WriteValue((byte)MessageType); streamer.WriteValue((byte)Command); streamer.WriteValue((byte)Priority); streamer.WriteString(Identifier); //.WriteValue(ItemId); streamer.WriteValue(Retry); streamer.WriteValue(ArrivedTime); streamer.WriteValue(Creation); streamer.WriteValue(Modified); streamer.WriteValue(Duration); streamer.WriteValue((byte)TransformType); streamer.WriteString(Host); streamer.WriteString(Sender); streamer.WriteString(Label); streamer.Flush(); }
const int offset = 0;//9; void Read() { //first byte is SerialContextType try { //0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 //t b t b t b t b------------------ItemId------------------b t b t b-----Arrived //31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 //-------b t b----------Sent------b t b------Modified------b t b--------b t b--- //60 61 62 63 64 65 66 67 68 69 70 //---b t b t b--count--b //streamer.WriteValue((byte)MessageState); //streamer.WriteValue((byte)Command); //streamer.WriteValue((byte)Priority); //streamer.WriteValue(ItemId); //streamer.WriteValue(Retry); //streamer.WriteValue(ArrivedTime); //streamer.WriteValue(SentTime); //streamer.WriteValue(Modified); //streamer.WriteValue(Expiration); //streamer.WriteValue(MessageId); //streamer.WriteValue((byte)TransformType); //streamer.WriteString(Destination); m_stream.Position = 0; using (BinaryStreamer streamer = new BinaryStreamer(m_stream, true)) { MessageState = (MessageState)streamer.ReadValue <byte>(); Command = (QueueCmd)streamer.ReadValue <byte>(); //Priority = (Priority)streamer.ReadValue<byte>(); ItemId = streamer.ReadValue <Guid>(); Retry = streamer.ReadValue <byte>(); ArrivedTime = streamer.ReadValue <DateTime>(); //SentTime = streamer.ReadValue<DateTime>(); Modified = streamer.ReadValue <DateTime>(); Expiration = streamer.ReadValue <int>(); //MessageId = streamer.ReadValue <int>(); TransformType = (TransformTypes)streamer.ReadValue <byte>(); QueueName = streamer.ReadString(); } m_stream.Position = 0; //m_stream.Position = 0; //MessageState = (MessageState)m_stream.PeekByte(offset + 1); //Command = (QueueCmd)m_stream.PeekByte(offset + 3); //Priority = (Priority)m_stream.PeekByte(offset + 5); //ItemId = new Guid(m_stream.PeekBytes(offset + 7, 16)); //Retry = (byte)m_stream.PeekByte(offset + 24); //ArrivedTime = (DateTime)m_stream.PeekDateTime(offset + 26); ////SentTime = (DateTime)m_stream.PeekDateTime(offset + 35); //Modified = (DateTime)m_stream.PeekDateTime(offset + 44); //Expiration = m_stream.PeekInt32(offset + 53); ////MessageId = m_stream.PeekInt32(offset + 58); //TransformType = (TransformTypes)m_stream.PeekByte(offset + 63); //int counter = 0; //m_stream.PeekString(offset + 65, out counter); } catch (Exception ex) { throw new MessageException(Messaging.MessageState.StreamReadWriteError, "QueueItem error: " + ex.Message); } }