public void RecieveMessage(object connectionInfo)
{
ConnectionInfo clientInfo = (ConnectionInfo)connectionInfo;
while (clientInfo.Client.Connected)
{
byte[] data = new byte[1024];
int amount;
MemoryStream messageContainer = new MemoryStream();
do
{
try
{
amount = clientInfo.Client.Receive(data);
messageContainer.Write(data, 0, amount);
}
catch
{
Console.WriteLine("Connection lost");
}
} while (clientInfo.Client.Available > 0);
if (messageContainer.GetBuffer().Length > 0)
{
Message message = messageSerializer.Deserialize(messageContainer.GetBuffer());
HandleMessage(message, clientInfo);
}
}
}
public async Task <T> RequestAsync <T>(AutoValidatedRequest request) where T : class
{
Log(request, $"Uri: /{request.Uri}");
var data = await GetDataAsync(request).ConfigureAwait(false);
var deserializedData = _serializer.Deserialize <T>(data);
#if DEBUG
lock (_nullableTypes)
{
var nullProperties = deserializedData.GetNullMembers();
_nullableTypes.Add(nullProperties);
var nullableTypes = _nullableTypes.GetUncheckedNulls();
if (nullableTypes != default)
{
var today = DateTime.Now.ToShortDateString();
var properties = string.Join(Environment.NewLine, nullableTypes.Select(kvp => $"{kvp.Key}, {today}, total {kvp.Value}"));
Log(request, $"Aggregate list of null properties:{Environment.NewLine + properties}");
}
}
#endif
return(deserializedData);
}
public void When_Deserialize_With_Generic_Should_Return_expected_Object()
{
var msg = _serializer.Deserialize <Message>(SimpleMsgJson);
msg.Should().BeOfType <Message>();
ValidateMessage(msg);
}
public bool HandleMessageReceived(string serializedMessage)
{
EndpointMessage responseMessage;
// TODO(AFL): error handling
if (!_responseDeserializer.Deserialize(serializedMessage, out responseMessage))
{
return(false);
}
if (!string.IsNullOrEmpty(responseMessage.Destination) &&
!string.Equals(responseMessage.Destination, _client.Options.ClientOptions.ClientId))
{
return(true);
}
// TODO(AFL): error handling
TResponse response;
if (!_responseDeserializer.Deserialize(responseMessage, out response))
{
return(false);
}
_responseRceivedHandler(response);
return(true);
}
public void Should_deserialize()
{
var request = Examples.Basic_get_request_causing_a_piggy_backed_response_with_token();
var bytes = _serializer.Serialize(request);
var message = _serializer.Deserialize(bytes);
Assert.IsNotNull(message);
Assert.IsInstanceOf <Request>(message);
Assert.AreEqual(2, message.OptionCount);
}
private void TcpWorker(CancellationToken token)
{
StartTcp();
while (!token.IsCancellationRequested)
{
try
{
TcpClient newClient = Tcp.AcceptTcpClient();
Action <object> processData = new Action <object>(delegate(object tcp)
{
TcpClient client = (TcpClient)tcp;
client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
while (client.Connected)
{
try
{
// Retrieve the message from the network stream. This will handle everything from message headers, body and type parsing.
Platform.Networking.Messages.BaseMessage message = messageSerializer.Deserialize(client.GetStream());
// Don't log KeepAlive messages.
if (message.Command != 3)
{
// Log all message as JSON output during development, simplifies debugging.
log.LogInformation("UDP:" + System.Environment.NewLine + JsonConvert.SerializeObject(message));
}
messageProcessing.Process(message, ProtocolType.Tcp, null, client);
}
catch (Exception ex)
{
log.LogError(ex, "Failed to process incoming message.");
Disconnect(client);
}
}
Disconnect(client);
});
Thread threadProcessData = new Thread(new ParameterizedThreadStart(processData));
threadProcessData.Start(newClient);
}
catch (Exception ex)
{
log.LogError(ex, "TCP error");
// We'll sleep a short while before connecting, to avoid extensive resource usage.
Thread.Sleep(250);
}
}
}
public bool HandleMessageReceived(string serializedMessage)
{
EndpointMessage requestMessage;
if (!_requestDeserializer.Deserialize(serializedMessage, out requestMessage))
{
return(false);
}
var requestSource = requestMessage.Source;
var requestDestination = requestMessage.Destination;
// Ignore request if its meant for another bot
if (!string.IsNullOrEmpty(requestDestination) && !string.Equals(requestDestination, _client.Options.ClientOptions.ClientId))
{
return(true);
}
TRequest request;
if (!_requestDeserializer.Deserialize(requestMessage, out request))
{
return(false);
}
var response = _requestReceivedHandler(request);
var responseMessage = _responseSerializer.SerializeMessage(response);
responseMessage.Source = requestDestination;
responseMessage.Destination = requestSource;
var payload = _responseSerializer.SerializeWrapper(responseMessage);
var packedMessage = new MqttApplicationMessageBuilder()
.WithTopic(ResponseTopic)
.WithPayload(payload)
.WithQualityOfServiceLevel(_qosLevel)
.Build();
try
{
_client.PublishAsync(packedMessage, _cancellationToken.Token).Wait();
}
catch (Exception e)
{
Log.Error($"Failed to publish response message on topic \"{ResponseTopic}\". Exception: {e}");
throw;
}
return(true);
}
public async Task <bool> HandleMessageAsync(string messageType, string message)
{
try
{
JObject messageObject = MessageSerializer.Deserialize(message);
switch (messageType)
{
case "CustomerRegistered":
await HandleAsync(messageObject.ToObject <CustomerRegistered>());
break;
case "MaintenanceJobPlanned":
await HandleAsync(messageObject.ToObject <MaintenanceJobPlanned>());
break;
case "MaintenanceJobFinished":
await HandleAsync(messageObject.ToObject <MaintenanceJobFinished>());
break;
case "DayHasPassed":
await HandleAsync(messageObject.ToObject <DayHasPassed>());
break;
}
}
catch (Exception ex)
{
Log.Error(ex, $"Error while handling {messageType} event.");
}
return(true);
}
// Wysyła żądania do serwera i obsługuje odpowiedzi.
// Zwraca wysłany komunikat, odebrany komunikat od serwera i odpowiedź.
public Tuple <string, string, string> Run(OperationCommand Parameters)
{
// Tworzenie wiadomości na podstawie danych podanych przez użytkownika.
Message message = server.CreateMessageRequest(Parameters);
string messageString = MessageSerializer.Serialize(message); // Serializacja komunikatu do formy z zadania klucz#wartość.
data = Encoding.ASCII.GetBytes(messageString);
// Komunikat zostaje wysłany jako pojedynczy pakiet. W przypadku klasy UdpSocket nie ma potrzeby jawnego przekazywania punktu końcowego
// jeśli został zdefiniowany w konstruktorze.
socket.Send(data, data.Length);
string sended = ($"> {ipep.ToString()}: {Encoding.ASCII.GetString(data)}");
data = socket.Receive(ref ipep);
string stringData = Encoding.ASCII.GetString(data, 0, data.Length);
string received = ($"< {ipep.ToString()}: {stringData}");
// Obsługa odpowiedzi.
Message response = MessageSerializer.Deserialize(stringData); // Deserializacja odpowiedzi od serwera.
string responsedata = "blad";
if (response != null && response.Fields != null)
{
response.Fields.TryGetValue(ProtocolStrings.ResultField, out responsedata);
}
return(new Tuple <string, string, string>(sended, received, responsedata));
}
static void Main(string[] args)
{
Data d = new Data {
CurrentDateTime = DateTime.Now, DataId = 1
};
Data d1 = new Data {
CurrentDateTime = DateTime.Now, DataId = 2
};
Data d2 = new Data {
CurrentDateTime = DateTime.Now, DataId = 3
};
CustomCollection cc = new CustomCollection
{
List = new List <Data> {
d, d1, d2
}
};
//This is the xml
string xml = MessageSerializer <CustomCollection> .Serialize(cc);
//This is deserialising it back to the original collection
CustomCollection collection = MessageSerializer <CustomCollection> .Deserialize(xml);
}
public static void SetUDPConnection()
{
var IPendPoint = new IPEndPoint(IPAddress.Any, SERVERUDPPORT);
var socketListener = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
socketListener.Bind(IPendPoint);
EndPoint remotePoint = new IPEndPoint(IPAddress.Any, 0);
byte[] data = new byte[1024];
while (true)
{
int amount = socketListener.ReceiveFrom(data, ref remotePoint);
Message message = messageSerializer.Deserialize(data, amount);
if (message.messageType == Message.MessageType[6])
{
Message messageResponse = new Message()
{
IPAdress = CommonInfo.GetHostsIPAddress().ToString(), messageType = Message.MessageType[7], serverPort = SERVERTCPPORT
};
var iPaddress = IPAddress.Parse(message.IPAdress);
IPEndPoint remoteEndPoint = new IPEndPoint(iPaddress, message.clientPort);
socketListener.SendTo(messageSerializer.Serialize(messageResponse), remoteEndPoint);
}
}
}
private void SocketListener_DataReceived(object sender, SocketEventArgs e)
{
var connection = (TcpConnection)e.Socket.UserToken;
var message = serializer.Deserialize(e.Data);
dispatcher.Dispatch(connection, message);
}
public static void SetUDPConnection()
{
var IPendPoint = new IPEndPoint(IPAddress.Any, ServerUdpPort);
var socketListener = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
socketListener.Bind(IPendPoint);
Console.WriteLine("UDP севрер готов!");
EndPoint remotePoint = new IPEndPoint(IPAddress.Any, 0);
byte[] data = new byte[MessageCapacity];
while (true)
{
int amount = socketListener.ReceiveFrom(data, ref remotePoint);
Message message = messageSerializer.Deserialize(data, amount);
if (message.messageType == Message.MessageType.SearchRequest)
{
Message messageResponse = new Message()
{
IPAdress = CommonInfo.GetHostsIPAddress().ToString(), messageType = Message.MessageType.SearchResponce,
serverPort = ServerTcpPort
};
var iPaddress = IPAddress.Parse(message.IPAdress);
IPEndPoint remoteEndPoint = new IPEndPoint(iPaddress, message.clientPort);
socketListener.SendTo(messageSerializer.Serialize(messageResponse), remoteEndPoint);
}
}
}
private async Task <Message> ReadMessageFromSocketAsync(WebSocket socket)
{
ArraySegment <byte> buffer = new ArraySegment <byte>(new byte[1024 * 4]);
string serializedMessage;
using (var ms = new MemoryStream())
{
WebSocketReceiveResult result;
do
{
result = await socket.ReceiveAsync(buffer, CancellationToken.None).ConfigureAwait(false);
ms.Write(buffer.Array, buffer.Offset, result.Count);
}while (!result.EndOfMessage);
ms.Seek(0, SeekOrigin.Begin);
using (var reader = new StreamReader(ms, Encoding.UTF8))
{
serializedMessage = await reader.ReadToEndAsync().ConfigureAwait(false);
}
}
return(MessageSerializer.Deserialize <Message>(serializedMessage));
}
public override void SendMessage(Message message)
{
var bytes = serializer.Serialize(message);
var webRequest = (HttpWebRequest)WebRequest.Create(bindingOption.Url);
webRequest.Method = WebRequestMethods.Http.Post;
webRequest.ContentType = "application/octet-stream";
webRequest.ContentLength = bytes.Length;
if (webRequest.SupportsCookieContainer)
{
webRequest.CookieContainer.Add(new Cookie(SessionCookieKey, guid.ToString()));
}
using (var inputStream = webRequest.GetRequestStream())
{
inputStream.Write(bytes, 0, bytes.Length);
}
using (var webResponse = webRequest.GetResponse())
{
if (message.Direction.HasFlag(Message.Directions.OneWay))
{
return;
}
bytes = new byte[webResponse.ContentLength];
using (var outputStream = webResponse.GetResponseStream())
{
outputStream.Read(bytes, 0, bytes.Length);
}
}
message = serializer.Deserialize(bytes);
Dispatch(message);
}
public async Task <bool> HandleMessageAsync(string messageType, string message, IDictionary <string, object> userproperties)
{
try
{
JObject messageObject = MessageSerializer.Deserialize(message);
switch (messageType)
{
case "RealtimeTriggered":
await HandleAsync(messageObject.ToObject <RealtimeTriggered>());
break;
case "SchedulePassed":
await HandleAsync(messageObject.ToObject <SchedulePassed>());
break;
case "TriggerTriggered":
await HandleAsync(messageObject.ToObject <SchedulePassed>());
break;
default:
break;
}
}
catch (Exception ex)
{
Log.Error(ex, $"Error while handling {messageType} event.");
}
return(true);
}
public async Task <bool> HandleMessageAsync(string messageType, string message)
{
try
{
JObject messageObject = MessageSerializer.Deserialize(message);
switch (messageType)
{
case "ClientCreated":
Handle(messageObject.ToObject <ClientCreated>());
break;
case "BranchCreated":
Handle(messageObject.ToObject <BranchCreated>());
break;
case "AccountCreated":
Handle(messageObject.ToObject <AccountCreated>());
break;
case "TransactionCreated":
await Handle(messageObject.ToObject <TransactionCreated>());
break;
}
}
catch (Exception ex)
{
Log.Error(ex, $"Error while handling {messageType} event.");
}
return(true);
}
public async Task <bool> HandleMessageAsync(string messageType, string message)
{
JObject messageObject = MessageSerializer.Deserialize(message);
switch (messageType)
{
case "CustomerRegistered":
await HandleAsync(messageObject.ToObject <CustomerRegistered>());
break;
case "MaintenanceJobPlanned":
await HandleAsync(messageObject.ToObject <MaintenanceJobPlanned>());
break;
case "MaintenanceJobFinished":
await HandleAsync(messageObject.ToObject <MaintenanceJobFinished>());
break;
case "DayHasPassed":
await HandleAsync(messageObject.ToObject <DayHasPassed>());
break;
default:
break;
}
return(true);
}
public async Task <bool> HandleMessageAsync(string messageType, string message)
{
JObject messageObject = MessageSerializer.Deserialize(message);
try
{
switch (messageType)
{
case "EnableOnlineAccessEvent":
await HandleAsync(messageObject.ToObject <EnableOnlineAccessEvent>()); //, _userManager);
break;
//case "VehicleRegistered":
// await HandleAsync(messageObject.ToObject<VehicleRegistered>());
// break;
//case "MaintenanceJobPlanned":
// await HandleAsync(messageObject.ToObject<MaintenanceJobPlanned>());
// break;
//case "MaintenanceJobFinished":
// await HandleAsync(messageObject.ToObject<MaintenanceJobFinished>());
// break;
default:
Console.WriteLine("Default case");
break;
}
}
catch (Exception ex)
{
}
return(true);
//throw new NotImplementedException();
}
public void SerializeDeserializeJson()
{
var serializer = MessageSerializer.Get(typeof(Mocks.TestMessage));
var message = GetStandardTestMessage(FieldFill.CompleteBeforeBindings);
var ms = new MemoryStream();
var writer = JsonReaderWriterFactory.CreateJsonWriter(ms, Encoding.UTF8);
MessageSerializer.Serialize(this.MessageDescriptions.GetAccessor(message), writer);
writer.Flush();
string actual = Encoding.UTF8.GetString(ms.ToArray());
string expected = @"{""age"":15,""Name"":""Andrew"",""Location"":""http:\/\/localtest\/path"",""Timestamp"":""2008-09-19T08:00:00Z""}";
Assert.AreEqual(expected, actual);
ms.Position = 0;
var deserialized = new Mocks.TestDirectedMessage();
var reader = JsonReaderWriterFactory.CreateJsonReader(ms, XmlDictionaryReaderQuotas.Max);
MessageSerializer.Deserialize(this.MessageDescriptions.GetAccessor(deserialized), reader);
Assert.AreEqual(message.Age, deserialized.Age);
Assert.AreEqual(message.EmptyMember, deserialized.EmptyMember);
Assert.AreEqual(message.Location, deserialized.Location);
Assert.AreEqual(message.Name, deserialized.Name);
Assert.AreEqual(message.Timestamp, deserialized.Timestamp);
}
public void Generic_properties_should_be_supported()
{
IMessageMapper mapper = new MessageMapper();
var serializer = new MessageSerializer
{
MessageMapper = mapper,
MessageTypes = new List <Type>(new[] { typeof(MessageWithGenericProperty) })
};
using (var stream = new MemoryStream())
{
var message = new MessageWithGenericProperty
{
GenericProperty = new GenericProperty <string>("test")
{
WhatEver = "a property"
}
};
serializer.Serialize(new IMessage[] { message }, stream);
stream.Position = 0;
Debug.WriteLine(new StreamReader(stream).ReadToEnd());
stream.Position = 0;
var result = serializer.Deserialize(stream)[0] as MessageWithGenericProperty;
Assert.NotNull(result);
Assert.AreEqual(message.GenericProperty.WhatEver, result.GenericProperty.WhatEver);
}
}
public async Task <bool> HandleMessageAsync(MessageTypes messageType, string message)
{
JObject messageObject = MessageSerializer.Deserialize(message);
try
{
switch (messageType)
{
case MessageTypes.Unknown:
break;
case MessageTypes.PackageRegistered:
await HandlePackageOrdersAsync(messageObject.ToObject <PackageRegistered>());
break;
case MessageTypes.DayHasBegun:
await HandlePackagesAsync(messageObject.ToObject <DayHasBegun>());
break;
}
}
catch (Exception ex)
{
string messageId = messageObject.Property("MessageId") != null?messageObject.Property("MessageId").Value <string>() : "[unknown]";
Console.WriteLine($"Error while handling {messageType} message with id {messageId}.\n{ex.ToString()}");
}
// always akcnowledge message - any errors need to be dealt with locally.
return(true);
}
public async Task <QueueMessage <T> > ReceiveAsync()
{
var message = await _queueClient.ReceiveAsync();
if (message == null)
{
return(null);
}
var body = message.GetBody <string>();
var item = await MessageSerializer.Deserialize(body);
var queueMessage = new QueueMessage <T>
{
MessageId = message.MessageId,
Item = await MessageSerializer.Deserialize(body)
};
try
{
queueMessage.CorrelationId = int.Parse(message.CorrelationId);
}
catch { }
return(queueMessage);
}
private TransportMessage DeserializeMessage(CloudQueueMessage rawMessage)
{
using (var stream = new MemoryStream(rawMessage.AsBytes))
{
var m = MessageSerializer.Deserialize(stream).FirstOrDefault() as MessageWrapper;
if (m == null)
{
throw new SerializationException("Failed to deserialize message with id: " + rawMessage.Id);
}
var message = new TransportMessage
{
Id = m.Id,
Body = m.Body,
CorrelationId = m.CorrelationId,
Recoverable = m.Recoverable,
ReplyToAddress = Address.Parse(m.ReplyToAddress),
TimeToBeReceived = m.TimeToBeReceived,
Headers = m.Headers,
MessageIntent = m.MessageIntent,
TimeSent = m.TimeSent,
IdForCorrelation = m.IdForCorrelation
};
message.Id = GetRealId(message.Headers) ?? message.Id;
message.IdForCorrelation = GetIdForCorrelation(message.Headers) ?? message.Id;
return(message);
}
}
public async Task <QueueMessage <T> > PeekAsync(long sequenceNumber)
{
BrokeredMessage message = await _queueClient.PeekAsync(sequenceNumber);
QueueMessage <T> queueMessage = null;
if (message != null)
{
var body = message.GetBody <string>();
queueMessage = new QueueMessage <T>
{
MessageId = message.MessageId,
Item = await MessageSerializer.Deserialize(body)
};
try
{
queueMessage.CorrelationId = int.Parse(message.CorrelationId);
}
catch { }
}
return(queueMessage);
}
public async Task CallHandlerAsync <TRequest, TResponse, TIntegrationEventHandler>(ILifetimeScope scope,
QueueOptions options) where TRequest : IntegrationEvent
where TResponse : IntegrationEvent
{
EventingBasicConsumer consumer = BuildChannel(options);
consumer.Received += async(model, args) =>
{
TRequest request = null;
using (ILifetimeScope innerScope = scope.BeginLifetimeScope())
using (MessageSerializer serializaer = new MessageSerializer())
using (IIntegrationEventHandler <TRequest, TResponse> handler = innerScope.Resolve <IIntegrationEventHandler <TRequest, TResponse> >())
{
IBasicProperties props = args.BasicProperties;
IBasicProperties replyProps = Channel.CreateBasicProperties();
replyProps.CorrelationId = props.CorrelationId;
request = Activator.CreateInstance <TRequest>();
if (args.Body.Length > 0)
{
request = serializaer.Deserialize <TRequest>(args.Body.ToArray())[0];
}
TResponse response = await handler.Handle(request);
Channel.BasicPublish("", props.ReplyTo, replyProps, serializaer.Serialize(response)[0]);
Channel.BasicAck(args.DeliveryTag, false);
}
};
}
TransportMessage DeserializeMessage(CloudQueueMessage rawMessage)
{
using (var stream = new MemoryStream(rawMessage.AsBytes))
{
object[] deserializedObjects;
try
{
deserializedObjects = MessageSerializer.Deserialize(stream, new List <Type> {
typeof(MessageWrapper)
});
}
catch (Exception)
{
throw new SerializationException("Failed to deserialize message with id: " + rawMessage.Id);
}
var m = deserializedObjects.FirstOrDefault() as MessageWrapper;
if (m == null)
{
throw new SerializationException("Failed to deserialize message with id: " + rawMessage.Id);
}
return(new TransportMessage(m.Id, m.Headers)
{
Body = m.Body,
CorrelationId = m.CorrelationId,
Recoverable = m.Recoverable,
ReplyToAddress = Address.Parse(m.ReplyToAddress),
TimeToBeReceived = m.TimeToBeReceived,
MessageIntent = m.MessageIntent
});
}
}
public void CanDeserializeXmlWithWhitespace()
{
var str =
@"<?xml version=""1.0"" encoding=""utf-8""?>
<Messages xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns=""http://tempuri.net/NServiceBus.Serializers.XML.Test"" xmlns:baseType=""NServiceBus.Saga.ISagaMessage"">
<MessageWithArray>
<SagaId>6bddc475-22a5-433b-a3ed-9edf00e8e353</SagaId>
<SomeInts>
<Int32>1405154</Int32>
</SomeInts>
</MessageWithArray>
</Messages>";
var data = Encoding.UTF8.GetBytes(str);
var serializer = new MessageSerializer
{
MessageMapper = new MessageMapper(),
MessageTypes = new List<Type> { typeof(MessageWithArray) }
};
var messages = serializer.Deserialize(new MemoryStream(data));
Assert.NotNull(messages);
Assert.That(messages, Has.Length.EqualTo(1));
Assert.That(messages[0], Is.TypeOf(typeof(MessageWithArray)));
var m = (MessageWithArray)messages[0];
Assert.IsNotNull(m.SomeInts);
Assert.That(m.SomeInts, Has.Length.EqualTo(1));
}
public void Deserialize_ShouldReturnAppropriateJObject()
{
//arrange
object message = new { Test = "test", Property = "property" };
string jsonString = JsonConvert.SerializeObject(message);
byte[] byteArray = Encoding.ASCII.GetBytes(jsonString);
JObject messageJObject = JObject.Parse(jsonString);
//act
JObject resultJObject = _testClass.Deserialize(byteArray);
//assert
resultJObject.Should().NotBeNull();
JToken.DeepEquals(resultJObject, messageJObject).Should().BeTrue();
}
public void Culture()
{
var mapper = new MessageMapper();
var serializer = new MessageSerializer();
serializer.MessageMapper = mapper;
serializer.MessageTypes = new List <Type>(new[] { typeof(MessageWithDouble) });
double val = 65.36;
var msg = new MessageWithDouble {
Double = val
};
Thread.CurrentThread.CurrentCulture = new CultureInfo("de-DE");
var stream = new MemoryStream();
serializer.Serialize(new[] { msg }, stream);
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
stream.Position = 0;
var msgArray = serializer.Deserialize(stream);
var m = msgArray[0] as MessageWithDouble;
Assert.AreEqual(val, m.Double);
stream.Dispose();
}
public void ReceiveClientMessages()
{
byte[] data = new byte[2048];
int amount;
do
{
MemoryStream messageContainer = new MemoryStream();
try
{
do
{
amount = listeningClientMessagesSocket.Receive(data);
messageContainer.Write(data, 0, amount);
} while (listeningClientMessagesSocket.Available > 0);
Message recievedMessage = messageSerializer.Deserialize(messageContainer.GetBuffer(),
messageContainer.GetBuffer().Length);
DefineMessageType(recievedMessage);
}
catch
{
if (!IsClientConnected())
{
isConnected = false;
}
}
} while (isConnected);
}
private static object EncoderTest(MessageSerializer target, IExtensible msg)
{
byte[] buf1 = target.Serialize(msg);
byte[] buf2 = target.Serialize(target.Deserialize(buf1));
Assert.IsNotNull(buf1);
Assert.IsNotNull(buf2);
Assert.AreEqual(buf1.Length, buf2.Length);
Assert.IsTrue(buf1.SequenceEqual(buf2));
return msg;
}
public void CanSerializeAndBack()
{
var serializer = new MessageSerializer
{
MessageMapper = new MessageMapper(),
MessageTypes = new List<Type> { typeof(MessageWithArray) }
};
var message = new MessageWithArray(Guid.NewGuid(), new int[] { 1234, 5323 });
var stream = new MemoryStream();
serializer.Serialize(new object[] { message }, stream);
stream.Position = 0;
var messages = serializer.Deserialize(stream);
Assert.NotNull(messages);
Assert.That(messages, Has.Length.EqualTo(1));
Assert.That(messages[0], Is.TypeOf(typeof(MessageWithArray)));
var m = (MessageWithArray)messages[0];
Assert.IsNotNull(m.SomeInts);
Assert.That(m.SomeInts, Has.Length.EqualTo(2));
Assert.AreEqual(1234, m.SomeInts[0]);
Assert.AreEqual(5323, m.SomeInts[1]);
}
