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);
}
protected void RegisterMessageType <T>(Address address)
{
MessageMapper.Initialize(new[] { typeof(T) });
MessageSerializer.Initialize(new[] { typeof(T) });
router.RegisterRoute(typeof(T), address);
MessageMetadataRegistry.RegisterMessageType(typeof(T));
}
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 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 XmlSerializerFacade(params Type[] objectTypes)
{
mapper = new MessageMapper();
serializer = new XmlMessageSerializer(mapper);
mapper.Initialize(objectTypes);
serializer.Initialize(objectTypes);
}
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 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 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);
}
}
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 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 static IMessageSerializer Create <T>()
{
var types = new List <Type> {
typeof(T)
};
var mapper = new MessageMapper();
mapper.Initialize(types);
var serializer = new XmlMessageSerializer(mapper);
serializer.Initialize(types);
return(serializer);
}
public static TransportMessage Serialize <T>(T message)
{
var s = new XmlMessageSerializer(new MessageMapper());
s.Initialize(new [] { typeof(T) });
var m = EmptyTransportMessage();
using (var stream = new MemoryStream())
{
s.Serialize(new object[] { message }, stream);
m.Body = stream.ToArray();
}
return(m);
}
public static XmlMessageSerializer Create <T>(MessageMapper mapper = null)
{
var types = new List <Type> {
typeof(T)
};
if (mapper == null)
{
mapper = new MessageMapper();
}
mapper.Initialize(types);
var serializer = new XmlMessageSerializer(mapper, new Conventions());
serializer.Initialize(types);
return(serializer);
}
public void Serialize_Deserialize_TransportMessage()
{
var types = new List <Type> {
typeof(C1), typeof(C2)
};
var mapper = new MessageMapper();
mapper.Initialize(types);
var serializer = new XmlMessageSerializer(mapper);
serializer.Initialize(types);
var transportMessage = new TransportMessage();
transportMessage.Id = Guid.NewGuid().ToString();
transportMessage.IdForCorrelation = Guid.NewGuid().ToString();
transportMessage.ReturnAddress = Guid.NewGuid().ToString();
transportMessage.WindowsIdentityName = string.Empty;
transportMessage.TimeSent = DateTime.Now;
transportMessage.Headers = new List <HeaderInfo>();
transportMessage.Body = new object[] { new C1()
{
Data = "o'tool"
}, new C2()
{
Data = "Timmy"
} };
var newTransportMessage = Execute(transportMessage, serializer);
var messages = newTransportMessage.Body;
Assert.AreEqual(2, messages.Count());
Assert.AreEqual(1, messages.Count(x => x is C1));
Assert.AreEqual(1, messages.Count(x => x is C2));
Assert.AreEqual("o'tool", ((C1)messages.First(x => x is C1)).Data);
Assert.AreEqual("Timmy", ((C2)messages.First(x => x is C2)).Data);
Assert.AreEqual(transportMessage.Id, newTransportMessage.Id);
Assert.AreEqual(transportMessage.IdForCorrelation, newTransportMessage.IdForCorrelation);
Assert.AreEqual(transportMessage.ReturnAddress, newTransportMessage.ReturnAddress);
Assert.AreEqual(transportMessage.TimeSent, newTransportMessage.TimeSent);
Assert.AreEqual(transportMessage.Headers, newTransportMessage.Headers);
Assert.AreNotSame(transportMessage, newTransportMessage);
}
public static TransportMessage Serialize <T>(T message, bool nullReplyToAddress = false, MessageMapper mapper = null)
{
var s = new XmlMessageSerializer(mapper ?? new MessageMapper(), new Conventions());
s.Initialize(new[] { typeof(T) });
var m = EmptyTransportMessage();
if (nullReplyToAddress)
{
m = new TransportMessage();
}
using (var stream = new MemoryStream())
{
s.Serialize(message, stream);
m.Body = stream.ToArray();
}
m.Headers[Headers.EnclosedMessageTypes] = typeof(T).FullName;
return(m);
}
protected void RegisterMessageType <T>(Address address)
{
MessageMapper.Initialize(new[] { typeof(T) });
MessageSerializer.Initialize(new[] { typeof(T) });
unicastBus.RegisterMessageType(typeof(T), address);
}
