/// <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);
}
}
