public UsingRhinoQueuesTransport()
{
if (Directory.Exists("test.esent"))
{
Directory.Delete("test.esent", true);
}
var serviceLocator = new CastleServiceLocator(new WindsorContainer());
messageSerializer = new XmlMessageSerializer(new DefaultReflection(), serviceLocator);
transport = new RhinoQueuesTransport(
new Uri("rhino.queues://localhost:23456/q"),
new EndpointRouter(),
messageSerializer,
1,
"test.esent",
IsolationLevel.Serializable,
5,
false,
new RhinoQueuesMessageBuilder(messageSerializer, serviceLocator),
new QueueManagerConfiguration(),
new TransactionScopeStrategy()
);
transport.Start();
}
private void VerifyMessageHeaderIsPassed(Action <IOutboundMessage> setHeaderAction, Action <IInboundMessageHeaders> checkHeaderAction)
{
byte[] data;
var serializer = new XmlMessageSerializer();
OutboundMessage.Set(setHeaderAction);
var message = new PingMessage();
using (MemoryStream output = new MemoryStream())
{
serializer.Serialize(output, message);
data = output.ToArray();
}
Trace.WriteLine(OutboundMessage.Headers.MessageType);
Trace.WriteLine(Encoding.UTF8.GetString(data));
using (MemoryStream input = new MemoryStream(data))
{
serializer.Deserialize(input);
checkHeaderAction(CurrentMessage.Headers);
}
}
private void VerifyMessageHeaderIsPassed(Action<IOutboundMessage> setHeaderAction, Action<IInboundMessageHeaders> checkHeaderAction)
{
byte[] data;
var serializer = new XmlMessageSerializer();
OutboundMessage.Set(setHeaderAction);
var message = new PingMessage();
using (MemoryStream output = new MemoryStream())
{
serializer.Serialize(output, message);
data = output.ToArray();
}
Trace.WriteLine(OutboundMessage.Headers.MessageType);
Trace.WriteLine(Encoding.UTF8.GetString(data));
using (MemoryStream input = new MemoryStream(data))
{
serializer.Deserialize(input);
checkHeaderAction(CurrentMessage.Headers);
}
}
public void Can_roundtrip_with_datetime_on_non_english_culture(string cultureName)
{
var oldCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo(cultureName);
try
{
var serializer = new XmlMessageSerializer(new DefaultReflection(),
new CastleServiceLocator(new WindsorContainer()));
var stream = new MemoryStream();
var date = DateTime.Now;
serializer.Serialize(new object[] { new Bar {
Date = date
} }, stream);
stream.Position = 0;
var bar = (Bar)serializer.Deserialize(stream)[0];
Assert.Equal(date, bar.Date);
}
finally
{
Thread.CurrentThread.CurrentCulture = oldCulture;
}
}
public void The_xml_message_serializer_should_rock_the_house()
{
byte[] serializedMessageData;
var serializer = new XmlMessageSerializer();
OutboundMessage.Set(x =>
{
x.SetSourceAddress("msmq://localhost/queue_name");
x.SetDestinationAddress("msmq://remotehost/queue_name");
x.SetResponseAddress("msmq://localhost/response_queue");
x.SetFaultAddress("msmq://localhost/fault_queue");
x.SetRetryCount(7);
});
using (MemoryStream output = new MemoryStream())
{
serializer.Serialize(output, _message);
serializedMessageData = output.ToArray();
Trace.WriteLine(Encoding.UTF8.GetString(serializedMessageData));
}
using (MemoryStream input = new MemoryStream(serializedMessageData))
{
SerializationTestMessage receivedMessage = serializer.Deserialize(input) as SerializationTestMessage;
Assert.AreEqual(_message, receivedMessage);
}
}
void VerifyMessageHeaderIsPassed(Action <ISendContext <PingMessage> > setHeaderAction,
Action <IConsumeContext> checkHeaderAction)
{
byte[] data;
var serializer = new XmlMessageSerializer();
var message = new PingMessage();
using (var output = new MemoryStream())
{
var sendContext = new SendContext <PingMessage>(message);
setHeaderAction(sendContext);
serializer.Serialize(output, sendContext);
data = output.ToArray();
}
//Trace.WriteLine(Encoding.UTF8.GetString(data));
using (var input = new MemoryStream(data))
{
var receiveContext = ReceiveContext.FromBodyStream(input);
serializer.Deserialize(receiveContext);
checkHeaderAction(receiveContext);
}
}
public void Setup()
{
ObjectBuilder = MockRepository.GenerateMock <IObjectBuilder>();
XmlMessageSerializer serializer = new XmlMessageSerializer();
ObjectBuilder.Stub(x => x.GetInstance <XmlMessageSerializer>()).Return(serializer);
EndpointFactory = EndpointFactoryConfigurator.New(x =>
{
x.SetObjectBuilder(ObjectBuilder);
x.RegisterTransport <TTransport>();
x.SetDefaultSerializer <XmlMessageSerializer>();
AdditionalEndpointFactoryConfiguration(x);
});
ObjectBuilder.Stub(x => x.GetInstance <IEndpointFactory>()).Return(EndpointFactory);
ServiceBusConfigurator.Defaults(x =>
{
x.SetObjectBuilder(ObjectBuilder);
x.SetReceiveTimeout(500.Milliseconds());
x.SetConcurrentConsumerLimit(Environment.ProcessorCount * 2);
});
EstablishContext();
}
public XmlSerializerFacade(params Type[] objectTypes)
{
mapper = new MessageMapper();
serializer = new XmlMessageSerializer(mapper);
mapper.Initialize(objectTypes);
serializer.Initialize(objectTypes);
}
public MessageSerializerAdapter()
{
var mapper = new MessageMapper();
var json = new JsonMessageSerializer(mapper);
_serializers.Add(json.ContentType, json);
var bson = new BsonMessageSerializer(mapper);
_serializers.Add(bson.ContentType, bson);
var binary = new BinaryMessageSerializer();
_serializers.Add(binary.ContentType, binary);
IList <Type> messageTypes = Configure.TypesToScan.Where(MessageConventionExtensions.IsMessageType).ToList();
var xml = new XmlMessageSerializer(mapper);
xml.Initialize(messageTypes);
_serializers.Add(xml.ContentType, xml);
_defaultSerializer = xml;
if (!_serializers.ContainsKey(_defaultSerializer.ContentType))
{
_serializers.Add(_defaultSerializer.ContentType, _defaultSerializer);
}
}
public void The_xml_message_serializer_should_rock_the_house()
{
byte[] serializedMessageData;
var serializer = new XmlMessageSerializer();
OutboundMessage.Set(x =>
{
x.SetSourceAddress("msmq://localhost/queue_name");
x.SetDestinationAddress("msmq://remotehost/queue_name");
x.SetResponseAddress("msmq://localhost/response_queue");
x.SetFaultAddress("msmq://localhost/fault_queue");
x.SetRetryCount(7);
});
using (MemoryStream output = new MemoryStream())
{
serializer.Serialize(output, _message);
serializedMessageData = output.ToArray();
Trace.WriteLine(Encoding.UTF8.GetString(serializedMessageData));
}
using (MemoryStream input = new MemoryStream(serializedMessageData))
{
SerializationTestMessage receivedMessage = serializer.Deserialize(input) as SerializationTestMessage;
Assert.AreEqual(_message, receivedMessage);
}
}
public void EndpointSendAndReceive()
{
using (var management = new RabbitMqEndpointManagement(_queue))
{
management.BindQueue(_queue.Name, _exchange.Name, ExchangeType.Fanout, "", null);
}
IMessageSerializer serializer = new XmlMessageSerializer();
var message = new BugsBunny {Food = "Carrot"};
IDuplexTransport transport = _factory.BuildLoopback(new TransportSettings(_exchange));
IOutboundTransport error = _factory.BuildError(new TransportSettings(_error));
var sendEndpoint = new Endpoint(_exchange, serializer, transport, error,
new InMemoryInboundMessageTracker(5));
sendEndpoint.Send(message);
var receiveEndpoint = new Endpoint(_queue, serializer, transport, error,
new InMemoryInboundMessageTracker(5));
receiveEndpoint.Receive(o =>
{
return b =>
{
var bb = (BugsBunny)b;
Console.WriteLine(bb.Food);
};
}, TimeSpan.Zero);
}
public SerializationMapper(IMessageMapper mapper, Conventions conventions, Configure configure)
{
jsonSerializer = new JsonMessageSerializer(mapper);
xmlSerializer = new XmlMessageSerializer(mapper, conventions);
List<Type> messageTypes = configure.TypesToScan.Where(conventions.IsMessageType).ToList();
xmlSerializer.Initialize(messageTypes);
}
public void Can_handle_dictionaries_where_values_are_objects()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(),
new CastleServiceLocator(new WindsorContainer()));
var stream = new MemoryStream();
serializer.Serialize(new object[] { new ItemWithObjectDictionary()
{
Name = "abc", Arguments = new Dictionary <string, object>
{
{ "abc", "cdef" },
{ "def", 1 },
{ "123", new Dog {
Name = "Oscar"
} }
}
} }, stream);
stream.Position = 0;
stream.Position = 0;
var foo = (ItemWithObjectDictionary)serializer.Deserialize(stream)[0];
Assert.Equal("abc", foo.Name);
Assert.Equal("cdef", foo.Arguments["abc"]);
Assert.Equal(1, (int)foo.Arguments["def"]);
Assert.Equal("Oscar", ((Dog)foo.Arguments["123"]).Name);
}
public void Adding_then_removing_will_result_in_no_subscriptions()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel());
var msg = new Message();
serializer.Serialize(new object[] { new AddSubscription
{
Endpoint = transactionalTestQueueEndpoint,
Type = typeof(TestMessage).FullName,
} }, msg.BodyStream);
msg.Extension = Guid.NewGuid().ToByteArray();
queue.OpenSiblngQueue(SubQueue.Subscriptions, QueueAccessMode.Send).Send(msg);
var subscriptionStorage = new MsmqSubscriptionStorage(new DefaultReflection(),
serializer,
testQueueEndPoint.Uri,
new EndpointRouter(),
new FlatQueueStrategy(new EndpointRouter(), testQueueEndPoint.Uri));
subscriptionStorage.Initialize();
subscriptionStorage.RemoveSubscription(typeof(TestMessage).FullName, transactionalTestQueueEndpoint.Uri.ToString());
var uris = subscriptionStorage
.GetSubscriptionsFor(typeof(TestMessage));
Assert.Equal(0, uris.Count());
}
public static IMessageSerializer Create(Type t)
{
var found = (IMessageSerializer)cache[t];
if (found != null)
{
return(found);
}
lock (cache)
{ // double-checked
found = (IMessageSerializer)cache[t];
if (found != null)
{
return(found);
}
var types = new List <Type> {
t
};
var mapper = new MessageMapper();
mapper.Initialize(types);
var serializer = new XmlMessageSerializer(mapper);
serializer.Initialize(types);
cache[t] = serializer;
return(serializer);
}
}
public void Trying_to_send_more_than_256_objects_will_fail()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(),
new CastleServiceLocator(new WindsorContainer()));
Assert.Throws <UnboundedResultSetException>(() => serializer.Serialize(new object[257], new MemoryStream()));
}
public SerializationMapper(IMessageMapper mapper, Conventions conventions, Configure configure)
{
jsonSerializer = new JsonMessageSerializer(mapper);
xmlSerializer = new XmlMessageSerializer(mapper, conventions);
var messageTypes = configure.TypesToScan.Where(conventions.IsMessageType).ToList();
xmlSerializer.Initialize(messageTypes);
}
public void Can_read_subscription_from_queue()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(),
new CastleServiceLocator(new WindsorContainer()));
var msg = new Message();
serializer.Serialize(new object[] { new AddSubscription
{
Endpoint = transactionalTestQueueEndpoint,
Type = typeof(TestMessage).FullName,
} }, msg.BodyStream);
msg.Extension = Guid.NewGuid().ToByteArray();
queue.OpenSiblngQueue(SubQueue.Subscriptions, QueueAccessMode.Send).Send(msg);
var subscriptionStorage = new MsmqSubscriptionStorage(new DefaultReflection(),
serializer,
testQueueEndPoint.Uri,
new EndpointRouter(),
new FlatQueueStrategy(new EndpointRouter(), testQueueEndPoint.Uri));
subscriptionStorage.Initialize();
var uri = subscriptionStorage
.GetSubscriptionsFor(typeof(TestMessage))
.Single();
Assert.Equal(transactionalTestQueueEndpoint.Uri, uri);
}
public void EndpointSendAndReceive()
{
using (var management = new RabbitMqEndpointManagement(_queue))
{
management.BindQueue(_queue.Name, _exchange.Name, ExchangeType.Fanout, "", null);
}
IMessageSerializer serializer = new XmlMessageSerializer();
var message = new BugsBunny {
Food = "Carrot"
};
IDuplexTransport transport = _factory.BuildLoopback(new TransportSettings(_exchange));
IOutboundTransport error = _factory.BuildError(new TransportSettings(_error));
var sendEndpoint = new Endpoint(_exchange, serializer, transport, error, new InMemoryInboundMessageTracker(5));
sendEndpoint.Send(message);
var receiveEndpoint = new Endpoint(_queue, serializer, transport, error, new InMemoryInboundMessageTracker(5));
receiveEndpoint.Receive(o =>
{
return(b =>
{
var bb = (BugsBunny)b;
Console.WriteLine(bb.Food);
});
}, TimeSpan.Zero);
}
public MultiDeserializer(Configure config, Conventions conventions, IMessageSerializer defaultSerializer,
IMessageMapper mapper,
LogicalMessageFactory logicalMessageFactory, MessageMetadataRegistry metadataRegistry)
{
_defaultSerializer = defaultSerializer;
_logicalMessageFactory = logicalMessageFactory;
_metadataRegistry = metadataRegistry;
var json = new JsonMessageSerializer(mapper);
serializers.Add(json.ContentType, json);
var bson = new BsonMessageSerializer(mapper);
serializers.Add(bson.ContentType, bson);
var binary = new BinaryMessageSerializer();
serializers.Add(binary.ContentType, binary);
var xml = new XmlMessageSerializer(mapper, conventions);
List <Type> messageTypes = config.TypesToScan.Where(conventions.IsMessageType).ToList();
xml.Initialize(messageTypes);
serializers.Add(xml.ContentType, xml);
if (!serializers.ContainsKey(_defaultSerializer.ContentType))
{
serializers.Add(_defaultSerializer.ContentType, _defaultSerializer);
}
}
public ChannelGraph()
{
DefaultContentType = new XmlMessageSerializer().ContentType;
_replyChannels.OnMissing = name =>
{
var channels = _channels.Where(x => x.Protocol() == name).ToArray();
var incoming = channels.FirstOrDefault(x => x.Incoming);
if (incoming != null)
{
return(incoming.Uri);
}
if (channels.Any())
{
var existing = channels.Select(x => $"{x.Uri} Incoming = {x.Incoming}").Join(", ");
throw new ArgumentOutOfRangeException($"No known reply channel for protocol '{name}', existing channels are {existing}");
}
else
{
throw new ArgumentOutOfRangeException($"No known channels for protocol '{name}'");
}
};
}
public void MoveErrorMessageToOriginQueue(QueueItem itm)
{
if (string.IsNullOrEmpty(itm.Id))
{
throw new ArgumentException("MessageId can not be null or empty");
}
if (itm.Queue.Type != QueueType.Error)
{
throw new ArgumentException("Queue is not of type Error, " + itm.Queue.Type);
}
var mgr = new ErrorManager();
// TODO:
// Check if Clustered Queue, due if Clustered && NonTransactional, then Error
//var deserializer = new XmlMessageSerializer();
XmlMessageSerializer _serializer = new XmlMessageSerializer();
using (var stream = new MemoryStream(UTF8Encoding.Default.GetBytes(itm.Content ?? "")))
{
var rcx = ReceiveContext.FromBodyStream(stream);
_serializer.Deserialize(rcx);
//var query = rcx.DestinationAddress.Query;
//var errorQueue = rcx.DestinationAddress.OriginalString.Replace(query, "") + "_error";
//mgr.InputQueue = new EndpointAddress(errorQueue);
mgr.ReturnMessageToSourceQueue(itm.Id, rcx);
}
}
public SerializationMapper(IMessageMapper mapper,Conventions conventions, ReadOnlySettings settings)
{
jsonSerializer = new JsonMessageSerializer(mapper);
xmlSerializer = new XmlMessageSerializer(mapper, conventions);
List<Type> messageTypes = settings.GetAvailableTypes().Where(conventions.IsMessageType).ToList();
xmlSerializer.Initialize(messageTypes);
}
private void InitializeSerializer()
{
var serializerTypes = _typesToPublish.Values.ToArray().Concat(new[] { typeof(TibcoEventPackage) }).ToArray(); //tell the serializer about our special types
Mapper.Initialize(serializerTypes);
_tibcoMessageSerializer = new XmlMessageSerializer(Mapper);
_tibcoMessageSerializer.Initialize(serializerTypes);
}
public SerializationMapper(IMessageMapper mapper, Conventions conventions, ReadOnlySettings settings)
{
jsonSerializer = new JsonMessageSerializer(mapper);
xmlSerializer = new XmlMessageSerializer(mapper, conventions);
List <Type> messageTypes = settings.GetAvailableTypes().Where(conventions.IsMessageType).ToList();
xmlSerializer.Initialize(messageTypes);
}
public EndpointFactoryDefaultSettings()
{
CreateMissingQueues = true;
PurgeOnStartup = false;
RequireTransactional = false;
Serializer = new XmlMessageSerializer();
TransactionTimeout = 30.Seconds();
IsolationLevel = IsolationLevel.Serializable;
}
public void Deserialize_BytesMessage_Exception()
{
var serializer = new XmlMessageSerializer <BytesMessage>();
var message = new TextMessage {
Body = MessageText
};
Assert.Throws <InvalidOperationException>(() => serializer.Deserialize(message));
}
public void Should_deserialize_into_the_proxy_object()
{
XmlMessageSerializer serializer = new XmlMessageSerializer();
using (var bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(InterfaceBasedMessageXml)))
{
object obj = serializer.Deserialize(bodyStream);
Assert.IsNotNull(obj);
}
}
public void Deserialize_TextMessage_CorrectResult()
{
var serializer = new XmlMessageSerializer <TextMessage>();
var result = serializer.Deserialize(new TextMessage {
Body = MessageText
});
Assert.That(result.Body == "testMessage");
}
public EndpointFactoryDefaultSettings()
{
CreateMissingQueues = true;
CreateTransactionalQueues = false;
PurgeOnStartup = false;
RequireTransactional = false;
Serializer = new XmlMessageSerializer();
TransactionTimeout = 30.Seconds();
IsolationLevel = IsolationLevel.Serializable;
}
public void Can_serialize_and_deserialize_byte_array()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel());
var stream = new MemoryStream();
serializer.Serialize(new object[] { new byte[] { 1, 2, 3, 4 } }, stream);
stream.Position = 0;
var actual = (byte[])serializer.Deserialize(stream)[0];
Assert.Equal(new byte[] { 1, 2, 3, 4 }, actual);
}
public static XmlMessageSerializer Create(params Type[] types)
{
var mapper = new MessageMapper();
mapper.Initialize(types);
var serializer = new XmlMessageSerializer(mapper, new Conventions());
serializer.Initialize(types);
return(serializer);
}
public void Should_not_cause_fatal_explosions_of_the_fiery_death_kind()
{
var serializer = new XmlMessageSerializer();
using (var bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(Version4Message)))
{
object obj = serializer.Deserialize(bodyStream);
Assert.IsNotNull(obj);
Assert.IsInstanceOf<ComplaintAdded>(obj);
}
}
public void Should_handle_the_uri_type()
{
var serializer = new XmlMessageSerializer();
using (var bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(AnotherVersion4Message)))
{
object obj = serializer.Deserialize(bodyStream);
Assert.IsNotNull(obj);
Assert.IsInstanceOf<ComplaintAdded>(obj);
}
}
public void Can_serialize_and_deserialize_byte_array()
{
var serializer = new XmlMessageSerializer();
var stream = new MemoryStream();
serializer.Serialize(new object[] { new byte[] { 1, 2, 3, 4 } }, stream);
stream.Position = 0;
var actual = (byte[])serializer.Deserialize(stream).As <byte[]>();
new byte[] { 1, 2, 3, 4 }.ShouldEqual(actual);
}
public void Should_deserialize_into_the_proxy_object()
{
XmlMessageSerializer serializer = new XmlMessageSerializer();
using (var bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(InterfaceBasedMessageXml)))
{
object obj = serializer.Deserialize(bodyStream);
Assert.IsNotNull(obj);
}
}
public void Deserialize_BytesMessage_CastResult()
{
var serializer = new XmlMessageSerializer <TextMessage>();
var message = new BytesMessage {
Body = Encoding.UTF8.GetBytes(MessageText)
};
var result = serializer.Deserialize(message);
Assert.That(result.Body == "testMessage");
}
public void Can_serialize_and_deserialize_DateTimeOffset()
{
var value = DateTimeOffset.Now;
var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel());
var stream = new MemoryStream();
serializer.Serialize(new object[] { value }, stream);
stream.Position = 0;
var actual = (DateTimeOffset)serializer.Deserialize(stream)[0];
Assert.Equal(value, actual);
}
public void Can_serialize_and_deserialize_primitive()
{
long ticks = DateTime.Now.Ticks;
var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel());
var stream = new MemoryStream();
serializer.Serialize(new object[] { ticks }, stream);
stream.Position = 0;
var actual = (long)serializer.Deserialize(stream)[0];
Assert.Equal(ticks, actual);
}
public EndpointFactoryDefaultSettings()
{
CreateMissingQueues = true;
CreateTransactionalQueues = false;
PurgeOnStartup = false;
RequireTransactional = false;
Serializer = new XmlMessageSerializer();
var messageSerializers = new SupportedMessageSerializers();
messageSerializers.AddSerializer(Serializer);
SupportedSerializers = messageSerializers;
TransactionTimeout = 30.Seconds();
IsolationLevel = IsolationLevel.Serializable;
RetryLimit = 5;
TrackerFactory = DefaultTrackerFactory;
}
public XmlTransportMessageSerializer(IMessageMapper mapper, IMessageRegisterer registerer, XmlMessageSerializer serializer)
{
_mapper = mapper;
_registrar = registerer;
_serializer = serializer;
}
public void MoveErrorMessageToOriginQueue(QueueItem itm)
{
if (string.IsNullOrEmpty(itm.Id))
throw new ArgumentException("MessageId can not be null or empty");
if (itm.Queue.Type != QueueType.Error)
throw new ArgumentException("Queue is not of type Error, " + itm.Queue.Type);
var mgr = new ErrorManager();
// TODO:
// Check if Clustered Queue, due if Clustered && NonTransactional, then Error
//var deserializer = new XmlMessageSerializer();
XmlMessageSerializer _serializer = new XmlMessageSerializer();
using (var stream = new MemoryStream(UTF8Encoding.Default.GetBytes(itm.Content ?? "")))
{
var rcx = ReceiveContext.FromBodyStream(stream);
_serializer.Deserialize(rcx);
//var query = rcx.DestinationAddress.Query;
//var errorQueue = rcx.DestinationAddress.OriginalString.Replace(query, "") + "_error";
//mgr.InputQueue = new EndpointAddress(errorQueue);
mgr.ReturnMessageToSourceQueue(itm.Id, rcx);
}
}
private void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
dynamic response = new ExpandoObject();
XmlMessageSerializer serializer = new XmlMessageSerializer(new MessageMapper());
var message = serializer.Deserialize(new MemoryStream(e.Message.Body)).First();
response.Endpoint = bus.InputAddress.Queue;
response.Time = DateTime.UtcNow;
response.type = message.GetType().ToString();
response.body = message;
response.headers = e.Message.Headers;
_monitor.Invoke("MessageReceived", response);
}
public void Just_how_fast_is_the_custom_xml_serializer()
{
var message = new SerializationTestMessage
{
DecimalValue = 123.45m,
LongValue = 098123213,
BoolValue = true,
ByteValue = 127,
IntValue = 123,
DateTimeValue = new DateTime(2008, 9, 8, 7, 6, 5, 4),
TimeSpanValue = 30.Seconds(),
GuidValue = Guid.NewGuid(),
StringValue = "Chris's Sample Code",
DoubleValue = 1823.172,
};
// var message = new PingMessage
// {
// CorrelationId = CombGuid.Generate()
// };
var serializer = new XmlMessageSerializer();
for (int i = 0; i < 10; i++)
{
byte[] data;
using (MemoryStream output = new MemoryStream())
{
serializer.Serialize(output, message);
data = output.ToArray();
}
using (MemoryStream input = new MemoryStream(data))
{
// serializer.Deserialize(input);
}
}
Stopwatch timer = Stopwatch.StartNew();
const int iterations = 50000;
for (int i = 0; i < iterations; i++)
{
using (MemoryStream output = new MemoryStream())
{
serializer.Serialize(output, message);
}
}
timer.Stop();
long perSecond = iterations*1000/timer.ElapsedMilliseconds;
var msg = string.Format("Serialize: {0}ms, Rate: {1} m/s", timer.ElapsedMilliseconds, perSecond);
Trace.WriteLine(msg);
byte[] sample;
using (MemoryStream output = new MemoryStream())
{
serializer.Serialize(output, message);
sample = output.ToArray();
}
timer = Stopwatch.StartNew();
for (int i = 0; i < 50000; i++)
{
using (MemoryStream input = new MemoryStream(sample))
{
serializer.Deserialize(input);
}
}
timer.Stop();
perSecond = iterations*1000/timer.ElapsedMilliseconds;
msg = string.Format("Deserialize: {0}ms, Rate: {1} m/s", timer.ElapsedMilliseconds, perSecond);
Trace.WriteLine(msg);
}
