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 void Interfaces_with_only_properties_should_be_mapped()
{
var mapper = new MessageMapper();
mapper.Initialize(new[] { typeof(InterfaceWithOnlyProperties) });
Assert.NotNull(mapper.GetMappedTypeFor(typeof(InterfaceWithOnlyProperties)));
}
public void Should_handle_interface_message_with_interface_property()
{
var messageMapper = new MessageMapper();
messageMapper.Initialize(new[]
{
typeof(IMessageWithInterfaceProperty)
});
var serializer = new JsonMessageSerializer(messageMapper);
IMessageWithInterfaceProperty message = new InterfaceMessageWithInterfacePropertyImplementation
{
InterfaceProperty = new InterfacePropertyImplementation
{
SomeProperty = "test"
}
};
using (var stream = new MemoryStream())
{
serializer.Serialize(message, stream);
stream.Position = 0;
var result = (IMessageWithInterfaceProperty) serializer.Deserialize(stream, new[]
{
typeof(IMessageWithInterfaceProperty)
})[0];
Assert.AreEqual(message.InterfaceProperty.SomeProperty, result.InterfaceProperty.SomeProperty);
}
}
public void Interfaces_with_methods_should_be_ignored()
{
var mapper = new MessageMapper();
mapper.Initialize(new[] { typeof(InterfaceWithMethods) });
Assert.Null(mapper.GetMappedTypeFor(typeof(InterfaceWithMethods)));
}
public void Deserialize_private_message_with_two_unrelated_interface_without_wrapping()
{
MessageMapper = new MessageMapper();
MessageMapper.Initialize(new[] { typeof(IMyEventA), typeof(IMyEventB) });
Serializer = new JsonMessageSerializer(MessageMapper);
using (var stream = new MemoryStream())
{
var msg = new CompositeMessage
{
IntValue = 42,
StringValue = "Answer"
};
Serializer.Serialize(msg, stream);
stream.Position = 0;
var result = Serializer.Deserialize(stream, new[] { typeof(IMyEventA), typeof(IMyEventB) });
var a = (IMyEventA) result[0];
var b = (IMyEventB) result[1];
Assert.AreEqual(42, b.IntValue);
Assert.AreEqual("Answer", a.StringValue);
}
}
public void Setup()
{
var messageMapper = new MessageMapper();
messageMapper.Initialize(new[] { typeof(IA), typeof(A) });
Serializer = new BsonMessageSerializer(messageMapper);
}
protected internal sealed override void Setup(FeatureConfigurationContext context)
{
var mapper = new MessageMapper();
var settings = context.Settings;
var messageMetadataRegistry = settings.Get<MessageMetadataRegistry>();
mapper.Initialize(messageMetadataRegistry.GetAllMessages().Select(m => m.MessageType));
var defaultSerializerAndDefinition = settings.GetMainSerializer();
var defaultSerializer = CreateMessageSerializer(defaultSerializerAndDefinition, mapper, settings);
var additionalDeserializers = new List<IMessageSerializer>();
foreach (var definitionAndSettings in context.Settings.GetAdditionalSerializers())
{
additionalDeserializers.Add(CreateMessageSerializer(definitionAndSettings, mapper, settings));
}
var resolver = new MessageDeserializerResolver(defaultSerializer, additionalDeserializers);
var logicalMessageFactory = new LogicalMessageFactory(messageMetadataRegistry, mapper);
context.Pipeline.Register(new DeserializeLogicalMessagesConnector(resolver, logicalMessageFactory, messageMetadataRegistry), "Deserializes the physical message body into logical messages");
context.Pipeline.Register(new SerializeMessageConnector(defaultSerializer, messageMetadataRegistry), "Converts a logical message into a physical message");
context.Container.ConfigureComponent(_ => mapper, DependencyLifecycle.SingleInstance);
context.Container.ConfigureComponent(_ => messageMetadataRegistry, DependencyLifecycle.SingleInstance);
context.Container.ConfigureComponent(_ => logicalMessageFactory, DependencyLifecycle.SingleInstance);
LogFoundMessages(messageMetadataRegistry.GetAllMessages().ToList());
}
public void Interfaces_with_methods_are_not_supported()
{
var mapper = new MessageMapper();
Assert.Throws<Exception>(() => mapper.Initialize(new[]
{
typeof(InterfaceWithMethods)
}));
}
public void Setup()
{
var types = new List<Type> { typeof(Sample_Message) };
var mapper = new MessageMapper();
mapper.Initialize(types);
serializer = new XmlMessageSerializer(mapper);
((XmlMessageSerializer)serializer).Initialize(types);
}
private static void ConfigureMessageMapper(Configure config)
{
var messageTypes = Configure.TypesToScan.Where(t => typeof(IMessage).IsAssignableFrom(t)).ToList();
var messageMapper = new MessageMapper();
messageMapper.Initialize(messageTypes);
config.Configurer.RegisterSingleton<IMessageMapper>(messageMapper);
}
public void Accept_Attributes_with_no_default_ctor_as_long_as_the_parameter_in_constructor_has_the_same_name_as_the_property()
{
var mapper = new MessageMapper();
mapper.Initialize(new[] { typeof(InterfaceWithCustomAttributeThatHasNoDefaultConstructor) });
var instance = mapper.CreateInstance(typeof (InterfaceWithCustomAttributeThatHasNoDefaultConstructor));
var attributes = instance.GetType().GetProperty("SomeProperty").GetCustomAttributes(typeof(CustomAttributeWithNoDefaultConstructor),true);
var attr = (CustomAttributeWithNoDefaultConstructor)attributes[0];
Assert.AreEqual(attr.Name, "Blah");
}
public void Interface_should_be_created()
{
var mapper = new MessageMapper();
mapper.Initialize(new[] { typeof(Interface) });
var result = mapper.CreateInstance<Interface>(null);
Assert.IsNotNull(result);
}
public void Attributes_on_properties_should_be_mapped()
{
var mapper = new MessageMapper();
mapper.Initialize(new[]{typeof(InterfaceWithPropertiesAndAttributes)});
Assert.IsTrue(PropertyContainsAttribute("SomeProperty",typeof(SomeAttribute),mapper.CreateInstance(typeof(InterfaceWithPropertiesAndAttributes))));
// Doesn't affect properties without attributes
Assert.IsFalse(PropertyContainsAttribute("SomeOtherProperty", typeof(SomeAttribute), mapper.CreateInstance(typeof(InterfaceWithPropertiesAndAttributes))));
}
public void Serialize_Deserialize_Multiple_Namespaces() {
var types = new List<Type> { typeof(C1), typeof(C2) };
var mapper = new MessageMapper();
mapper.Initialize(types);
var serializer = new XmlMessageSerializer(mapper);
serializer.Initialize(types);
Time(new IMessage[] { new C1() { Data = "o'tool" }, new C2() { Data = "Timmy" } }, serializer);
}
public void Using_xml_message_serialization()
{
IMessageMapper mapper = new MessageMapper();
var serializer = new MessageSerializer
{
MessageMapper = mapper,
MessageTypes = new List<Type>(new[] { typeof(TestMessage) })
};
ExecuteAndVerify(serializer);
}
private IStartableMessageBus Build() {
var messageTypes = MessageTypeConventions.ScanAssembliesForMessageTypes(assembliesToScan);
var messageMapper = new MessageMapper();
messageMapper.SetMessageTypeConventions(this.MessageTypeConventions);
messageMapper.Initialize(messageTypes);
var allMessageTypes = messageTypes.Concat(messageMapper.DynamicTypes);
MessageSerializer = new XmlMessageSerializer(messageMapper);
(MessageSerializer as XmlMessageSerializer).Initialize(messageTypes);
this.MessageHandlers.AddAssembliesToScan(assembliesToScan);
this.MessageHandlers.Init();
if (executeTheseHandlersFirst.Any())
this.MessageHandlers.ExecuteTheseHandlersFirst(executeTheseHandlersFirst);
if (executeTheseHandlersLast.Any())
this.MessageHandlers.ExecuteTheseHandlersLast(executeTheseHandlersLast);
// Get endpoint mapping
foreach (MessageEndpointMapping mapping in this.MessageEndpointMappingCollection) {
try {
var messageType = Type.GetType(mapping.Messages, false);
if (messageType != null && MessageTypeConventions.IsMessageType(messageType))
{
typesToEndpoints[messageType] = mapping.Endpoint.Trim();
continue;
}
} catch (Exception ex) {
Logger.Error("Problem loading message type: " + mapping.Messages, ex);
}
try {
var a = Assembly.Load(mapping.Messages);
foreach (var t in a.GetTypes().Where(t => MessageTypeConventions.IsMessageType(t)))
typesToEndpoints[t] = mapping.Endpoint.Trim();
} catch (Exception ex) {
throw new ArgumentException("Problem loading message assembly: " + mapping.Messages, ex);
}
}
var transport = TransportBuilder.Build();
var messageDispatcher = new MessageDispatcher(ServiceLocator, this.MessageHandlers);
var messageBus = new UnicastMessageBus(messageMapper, transport, messageDispatcher);
messageBus.MapMessageTypesToAddress(typesToEndpoints);
var performanceCounters = new PerformanceCounters();
messageBus.MessageReceived += performanceCounters.OnMessageReceived;
messageBus.MessageSent += performanceCounters.OnMessageSent;
messageBus.MessageFailed += performanceCounters.OnMessageFailure;
messageBus.MessageHandled += performanceCounters.OnMessageHandled;
return messageBus;
}
public void Configuration(IAppBuilder app)
{
var actorSystem = ActorSystem.Create("TestSystem");
actorSystem.ActorOf<EchoActor>("echo");
//register message types
var mapper = new MessageMapper()
.Add<Echo>();
ServiceLocator.Register<ActorSystem>(actorSystem);
ServiceLocator.Register<MessageMapper>(mapper);
app.MapSignalR();
}
private static JsonMessageSerializer CreateSerializer()
{
var mapper = new MessageMapper();
var ser = new JsonMessageSerializer(mapper);
//ser.JsonSerializerSettings.ContractResolver = new DefaultContractResolver
//{
// DefaultMembersSearchFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance
//};
//ser.JsonSerializerSettings.MissingMemberHandling = MissingMemberHandling.Error;
//ser.JsonSerializerSettings.TypeNameHandling = TypeNameHandling.All;
return ser;
}
public void Deserialize_message_without_concrete_implementation()
{
var mapper = new MessageMapper();
mapper.Initialize(new[] { typeof(ISuperMessageWithoutConcreteImpl) });
using (var stream = new MemoryStream())
{
Serializer.SkipArrayWrappingForSingleMessages = true;
var msg = mapper.CreateInstance<ISuperMessageWithoutConcreteImpl>();
msg.SomeProperty = "test";
Serializer.Serialize(new object[] { msg }, stream);
stream.Position = 0;
var result = (ISuperMessageWithoutConcreteImpl)Serializer.Deserialize(stream, new[] { typeof(ISuperMessageWithoutConcreteImpl) })[0];
Assert.AreEqual("test", result.SomeProperty);
}
}
/// <summary>
/// Use XML serialization that supports interface-based messages.
/// </summary>
/// <param name="config"></param>
/// <returns></returns>
public static Configure XmlSerializer(this Configure config)
{
if (!Configure.BuilderIsConfigured())
{
SetXmlSerializerAsDefault.UseXmlSerializer = true;
return config;
}
var messageTypes = Configure.TypesToScan.Where(t => t.IsMessageType()).ToList();
var mapper = new MessageMapper();
mapper.Initialize(messageTypes);
config.Configurer.RegisterSingleton<IMessageMapper>(mapper);
config.Configurer.RegisterSingleton<IMessageCreator>(mapper);//todo - Modify the builders to auto register all types
var serializer = new XmlMessageSerializer(mapper);
serializer.Initialize(messageTypes);
config.Configurer.RegisterSingleton<IMessageSerializer>(serializer);
return config;
}
//
// Fetch all messages from a user to a user
//
public ReadResponseMessage fetchMessagesFromUserToUser(String fromUser, String toUser)
{
List <Message> messages = new List <Message>();
ReadResponseMessage response;
try
{
List <BsonDocument> documents = col.Find(m => m["from"] == fromUser && m["to"] == toUser).ToList();
foreach (var doc in documents)
{
Message message = MessageMapper.toMessage(doc);
messages.Add(message);
}
response = new ReadResponseMessage(Status.STATUS.SUCCESS, messages, null);
}
catch (MongoWriteException err)
{
response = new ReadResponseMessage(Status.STATUS.ERROR, messages, err);
}
return(response);
}
public void SerializeInvalidCharacters()
{
IMessageMapper mapper = new MessageMapper();
var serializer = SerializerFactory.Create <MessageWithInvalidCharacter>();
var msg = mapper.CreateInstance <MessageWithInvalidCharacter>();
var sb = new StringBuilder();
sb.Append("Hello");
sb.Append((char)0x1C);
sb.Append("John");
msg.Special = sb.ToString();
using (var stream = new MemoryStream())
{
serializer.Serialize(new[] { msg }, stream);
stream.Position = 0;
var msgArray = serializer.Deserialize(stream);
var m = msgArray[0] as MessageWithInvalidCharacter;
Assert.AreEqual(sb.ToString(), m.Special);
}
}
public void Deserialize_message_with_interface_without_wrapping()
{
var messageMapper = new MessageMapper();
var serializer = new JsonMessageSerializer(messageMapper);
using (var stream = new MemoryStream())
{
serializer.Serialize(new SuperMessage
{
SomeProperty = "John"
}, stream);
stream.Position = 0;
var result = (SuperMessage)serializer.Deserialize(stream, new[]
{
typeof(SuperMessage),
typeof(IMyEvent)
})[0];
Assert.AreEqual("John", result.SomeProperty);
}
}
public async Task MessageBoardService_GetAsync_Returns_Two_Messages()
{
// Arrange
var options = new DbContextOptionsBuilder <MessageBoardDbContext>()
.UseInMemoryDatabase("MessageBoardDB")
.Options;
using (var dbContext = new MessageBoardDbContext(options))
{
// Clear existing messages
dbContext.Messages.RemoveRange(dbContext.Messages);
await dbContext.SaveChangesAsync();
// Initialize new messages
dbContext.Messages.Add(new MessageDb {
User = "******", Content = "Hello Tom.", Created = DateTime.Now.AddMinutes(5)
});
dbContext.Messages.Add(new MessageDb {
User = "******", Content = "Hi, Rick.", Created = DateTime.Now.AddMinutes(5)
});
await dbContext.SaveChangesAsync();
};
var mapper = new MessageMapper();
using (var dbContext = new MessageBoardDbContext(options))
{
var service = new MessageBoardService(mapper, dbContext);
// Act
var result = await service.GetAsync();
// Assert
Assert.Equal(2, result.Messages.Count());
};
}
public void SerializeClosedGenericListsInSameNamespace()
{
IMessageMapper mapper = new MessageMapper();
var serializer = SerializerFactory.Create <MessageWithClosedList>();
var msg = mapper.CreateInstance <MessageWithClosedList>();
msg.Items = new ItemList
{
new MessageWithListItem
{
Data = "Hello"
}
};
using (var stream = new MemoryStream())
{
serializer.Serialize(msg, stream);
stream.Position = 0;
var msgArray = serializer.Deserialize(stream);
var m = (MessageWithClosedList)msgArray[0];
Assert.AreEqual("Hello", m.Items.First().Data);
}
}
public void SerializeClosedGenericListsInAlternateNamespaceMultipleIListImplementations()
{
IMessageMapper mapper = new MessageMapper();
var serializer = SerializerFactory.Create <MessageWithClosedListInAlternateNamespaceMultipleIListImplementations>();
var msg = mapper.CreateInstance <MessageWithClosedListInAlternateNamespaceMultipleIListImplementations>();
msg.Items = new AlternateItemListMultipleIListImplementations
{
new MessageWithListItemAlternate
{
Data = "Hello"
}
};
using (var stream = new MemoryStream())
{
serializer.Serialize(msg, stream);
stream.Position = 0;
var msgArray = serializer.Deserialize(stream);
var m = (MessageWithClosedListInAlternateNamespaceMultipleIListImplementations)msgArray[0];
Assert.AreEqual("Hello", m.Items.First <MessageWithListItemAlternate>().Data);
}
}
public void Deserialize_message_with_concrete_implementation_and_interface()
{
var map = new[] { typeof(SuperMessageWithConcreteImpl), typeof(ISuperMessageWithConcreteImpl) };
var mapper = new MessageMapper();
mapper.Initialize(map);
using (var stream = new MemoryStream())
{
var msg = new SuperMessageWithConcreteImpl
{
SomeProperty = "test"
};
Serializer.Serialize(new object[] { msg }, stream);
stream.Position = 0;
var result = (ISuperMessageWithConcreteImpl)Serializer.Deserialize(stream, map)[0];
Assert.IsInstanceOf <SuperMessageWithConcreteImpl>(result);
Assert.AreEqual("test", result.SomeProperty);
}
}
public void When_Using_Property_WithXContainerAssignable_should_preserve_xml()
{
const string XmlElement = "<SomeClass xmlns=\"http://nservicebus.com\"><SomeProperty value=\"Bar\" /></SomeClass>";
const string XmlDocument = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" + XmlElement;
var messageWithXDocument = new MessageWithXDocument
{
Document = XDocument.Load(new StringReader(XmlDocument))
};
var messageWithXElement = new MessageWithXElement
{
Document = XElement.Load(new StringReader(XmlElement))
};
var messageMapper = new MessageMapper();
var serializer = new JsonMessageSerializer(messageMapper);
using (var stream = new MemoryStream())
{
serializer.Serialize(messageWithXDocument, stream);
stream.Position = 0;
var json = new StreamReader(stream).ReadToEnd();
stream.Position = 0;
var result = serializer.Deserialize(stream, new[]
{
typeof(MessageWithXDocument)
}).Cast<MessageWithXDocument>().Single();
Assert.AreEqual(messageWithXDocument.Document.ToString(), result.Document.ToString());
Assert.AreEqual(XmlElement, json.Substring(13, json.Length - 15).Replace("\\", string.Empty));
}
using (var stream = new MemoryStream())
{
serializer.Serialize(messageWithXElement, stream);
stream.Position = 0;
var json = new StreamReader(stream).ReadToEnd();
stream.Position = 0;
var result = serializer.Deserialize(stream, new[]
{
typeof(MessageWithXElement)
}).Cast<MessageWithXElement>().Single();
Assert.AreEqual(messageWithXElement.Document.ToString(), result.Document.ToString());
Assert.AreEqual(XmlElement, json.Substring(13, json.Length - 15).Replace("\\", string.Empty));
}
}
public void Test()
{
var expectedDate = new DateTime(2010, 10, 13, 12, 32, 42, DateTimeKind.Unspecified);
var expectedDateLocal = new DateTime(2010, 10, 13, 12, 32, 42, DateTimeKind.Local);
var expectedDateUtc = new DateTime(2010, 10, 13, 12, 32, 42, DateTimeKind.Utc);
var expectedGuid = Guid.NewGuid();
var obj = new A
{
AGuid = expectedGuid,
Data = new byte[32],
I = 23,
S = "Foo",
Ints = new List <int> {
12, 42
},
Bs = new List <B> {
new B {
BString = "aaa", C = new C {
Cstr = "ccc"
}
}, new BB {
BString = "bbbb", C = new C {
Cstr = "dddd"
}, BBString = "BBStr"
}
},
DateTime = expectedDate,
DateTimeLocal = expectedDateLocal,
DateTimeUtc = expectedDateUtc
};
new Random().NextBytes(obj.Data);
var output = new MemoryStream();
var messageMapper = new MessageMapper();
messageMapper.Initialize(new[] { typeof(IA), typeof(A) });
var serializer = new JsonMessageSerializer(messageMapper);
serializer.Serialize(obj, output);
output.Position = 0;
var result = serializer.Deserialize(output, new[] { typeof(A) });
Assert.DoesNotThrow(() => output.Position = 0, "Stream should still be open");
Assert.That(result[0], Is.TypeOf(typeof(A)));
var a = (A)result[0];
Assert.AreEqual(obj.Data, a.Data);
Assert.AreEqual(23, a.I);
Assert.AreEqual("Foo", a.S);
Assert.AreEqual(expectedDate.Kind, a.DateTime.Kind);
Assert.AreEqual(expectedDate, a.DateTime);
Assert.AreEqual(expectedDateLocal.Kind, a.DateTimeLocal.Kind);
Assert.AreEqual(expectedDateLocal, a.DateTimeLocal);
Assert.AreEqual(expectedDateUtc.Kind, a.DateTimeUtc.Kind);
Assert.AreEqual(expectedDateUtc, a.DateTimeUtc);
Assert.AreEqual("ccc", ((C)a.Bs[0].C).Cstr);
Assert.AreEqual(expectedGuid, a.AGuid);
Assert.IsInstanceOf <B>(a.Bs[0]);
Assert.IsInstanceOf <BB>(a.Bs[1]);
}
public ProductService(IProductRepository productRepository, ICatalogueService catalogueService)
{
_productRepository = productRepository;
_catalogueService = catalogueService;
_messageMapper = new MessageMapper();
}
private object GetObjectOfTypeFromNode(Type t, XmlNode node)
{
if (t.IsSimpleType())
{
return(GetPropertyValue(t, node));
}
if (t == typeof(WireEncryptedString))
{
if (EncryptionService != null)
{
var encrypted = GetObjectOfTypeFromNode(typeof(EncryptedValue), node) as EncryptedValue;
var s = EncryptionService.Decrypt(encrypted);
return(new WireEncryptedString {
Value = s
});
}
foreach (XmlNode n in node.ChildNodes)
{
if (n.Name.ToLower() == "encryptedbase64value")
{
var wes = new WireEncryptedString();
wes.Value = GetPropertyValue(typeof(String), n) as string;
return(wes);
}
}
}
if (typeof(IEnumerable).IsAssignableFrom(t))
{
return(GetPropertyValue(t, node));
}
object result = MessageMapper.CreateInstance(t);
foreach (XmlNode n in node.ChildNodes)
{
Type type = null;
if (n.Name.Contains(":"))
{
type = Type.GetType("System." + n.Name.Substring(0, n.Name.IndexOf(":")), false, true);
}
var prop = GetProperty(t, n.Name);
if (prop != null)
{
var val = GetPropertyValue(type ?? prop.PropertyType, n);
if (val != null)
{
propertyInfoToLateBoundPropertySet[prop].Invoke(result, val);
continue;
}
}
var field = GetField(t, n.Name);
if (field != null)
{
object val = GetPropertyValue(type ?? field.FieldType, n);
if (val != null)
{
fieldInfoToLateBoundFieldSet[field].Invoke(result, val);
continue;
}
}
}
return(result);
}
/// <summary>
/// Deserializes the given stream to an array of messages which are returned.
/// </summary>
/// <param name="stream"></param>
/// <returns></returns>
public IMessage[] Deserialize(Stream stream)
{
prefixesToNamespaces = new Dictionary <string, string>();
messageBaseTypes = new List <Type>();
var result = new List <IMessage>();
var doc = new XmlDocument();
doc.Load(XmlReader.Create(stream, new XmlReaderSettings {
CheckCharacters = false
}));
if (doc.DocumentElement == null)
{
return(result.ToArray());
}
foreach (XmlAttribute attr in doc.DocumentElement.Attributes)
{
if (attr.Name == "xmlns")
{
defaultNameSpace = attr.Value.Substring(attr.Value.LastIndexOf("/") + 1);
}
else
{
if (attr.Name.Contains("xmlns:"))
{
int colonIndex = attr.Name.LastIndexOf(":");
string prefix = attr.Name.Substring(colonIndex + 1);
if (prefix.Contains(BASETYPE))
{
Type baseType = MessageMapper.GetMappedTypeFor(attr.Value);
if (baseType != null)
{
messageBaseTypes.Add(baseType);
}
}
else
{
prefixesToNamespaces[prefix] = attr.Value;
}
}
}
}
if (doc.DocumentElement.Name.ToLower() != "messages")
{
object m = Process(doc.DocumentElement, null);
if (m == null)
{
throw new SerializationException("Could not deserialize message.");
}
result.Add(m as IMessage);
}
else
{
foreach (XmlNode node in doc.DocumentElement.ChildNodes)
{
object m = Process(node, null);
result.Add(m as IMessage);
}
}
defaultNameSpace = null;
return(result.ToArray());
}
public void TestInterfaces()
{
var output = new MemoryStream();
var messageMapper = new MessageMapper();
messageMapper.Initialize(new[]
{
typeof(IA),
typeof(IAImpl)
});
var obj = messageMapper.CreateInstance<IA>(
x =>
{
x.S = "kalle";
x.I = 42;
x.Data = new byte[23];
x.B = new B
{
BString = "BOO",
C = new C
{
Cstr = "COO"
}
};
}
);
new Random().NextBytes(obj.Data);
var serializer = new JsonMessageSerializer(messageMapper);
serializer.Serialize(obj, output);
output.Position = 0;
var filename = $"{GetType().Name}.{MethodBase.GetCurrentMethod().Name}.txt";
File.WriteAllBytes(filename, output.ToArray());
output.Position = 0;
var result = serializer.Deserialize(output, new[]
{
typeof(IAImpl)
});
Assert.DoesNotThrow(() => output.Position = 0, "Stream should still be open");
Assert.IsNotEmpty(result);
Assert.That(result, Has.Length.EqualTo(1));
Assert.That(result[0], Is.AssignableTo(typeof(IA)));
var a = (IA) result[0];
Assert.AreEqual(a.Data, obj.Data);
Assert.AreEqual(42, a.I);
Assert.AreEqual("kalle", a.S);
Assert.IsNotNull(a.B);
Assert.AreEqual("BOO", a.B.BString);
Assert.AreEqual("COO", ((C) a.B.C).Cstr);
}
public ClusterService(IClusterRepository clusterRepository)
{
_clusterRepository = clusterRepository;
_messageMapper = new MessageMapper();
}
public void Should_throw_for_non_registered_message()
{
var action = new Func <string>(() => MessageMapper.GetQueueName(typeof(NotRegisteredMessage)));
action.Invoking(m => m.Invoke()).Should().Throw <MessageMappingMissingException>();
}
public void Should_handle_types_correctly()
{
var expectedGuid = Guid.NewGuid();
var obj = new A
{
AGuid = expectedGuid,
Data = new byte[32],
I = 23,
S = "Foo",
Ints = new List<int>
{
12,
42
},
Bs = new List<B>
{
new B
{
BString = "aaa",
C = new C
{
Cstr = "ccc"
}
},
new BB
{
BString = "bbbb",
C = new C
{
Cstr = "dddd"
},
BBString = "BBStr"
}
}
};
new Random().NextBytes(obj.Data);
var output = new MemoryStream();
var messageMapper = new MessageMapper();
messageMapper.Initialize(new[]
{
typeof(IA),
typeof(A)
});
var serializer = new JsonMessageSerializer(messageMapper);
serializer.Serialize(obj, output);
output.Position = 0;
var result = serializer.Deserialize(output, new[]
{
typeof(A)
});
Assert.DoesNotThrow(() => output.Position = 0, "Stream should still be open");
Assert.That(result[0], Is.TypeOf(typeof(A)));
var a = (A) result[0];
Assert.AreEqual(obj.Data, a.Data);
Assert.AreEqual(23, a.I);
Assert.AreEqual("Foo", a.S);
Assert.AreEqual("ccc", ((C) a.Bs[0].C).Cstr);
Assert.AreEqual(expectedGuid, a.AGuid);
Assert.IsInstanceOf<B>(a.Bs[0]);
Assert.IsInstanceOf<BB>(a.Bs[1]);
}
public DeserializeLogicalMessagesConnector(MessageDeserializerResolver deserializerResolver, LogicalMessageFactory logicalMessageFactory, MessageMetadataRegistry messageMetadataRegistry, MessageMapper mapper)
{
this.deserializerResolver = deserializerResolver;
this.logicalMessageFactory = logicalMessageFactory;
this.messageMetadataRegistry = messageMetadataRegistry;
this.mapper = mapper;
}
public async Task <IStartableEndpoint> Initialize()
{
RegisterCriticalErrorHandler();
var concreteTypes = settings.GetAvailableTypes()
.Where(IsConcrete)
.ToList();
var featureActivator = BuildFeatureActivator(concreteTypes);
ConfigRunBeforeIsFinalized(concreteTypes);
var transportInfrastructure = InitializeTransportComponent();
var receiveConfiguration = BuildReceiveConfiguration(transportInfrastructure);
var routing = InitializeRouting(transportInfrastructure, receiveConfiguration);
var messageMapper = new MessageMapper();
settings.Set <IMessageMapper>(messageMapper);
pipelineComponent.AddRootContextItem <IMessageMapper>(messageMapper);
var featureStats = featureActivator.SetupFeatures(container, pipelineComponent.PipelineSettings, routing, receiveConfiguration);
settings.AddStartupDiagnosticsSection("Features", featureStats);
pipelineComponent.Initialize(builder, container);
container.ConfigureComponent(b => settings.Get <Notifications>(), DependencyLifecycle.SingleInstance);
var eventAggregator = new EventAggregator(settings.Get <NotificationSubscriptions>());
pipelineComponent.AddRootContextItem <IEventAggregator>(eventAggregator);
var queueBindings = settings.Get <QueueBindings>();
var receiveComponent = CreateReceiveComponent(receiveConfiguration, transportInfrastructure, pipelineComponent, queueBindings, eventAggregator);
var shouldRunInstallers = settings.GetOrDefault <bool>("Installers.Enable");
if (shouldRunInstallers)
{
var username = GetInstallationUserName();
if (settings.CreateQueues())
{
await receiveComponent.CreateQueuesIfNecessary(queueBindings, username).ConfigureAwait(false);
}
await RunInstallers(concreteTypes, username).ConfigureAwait(false);
}
settings.AddStartupDiagnosticsSection("Endpoint",
new
{
Name = settings.EndpointName(),
SendOnly = settings.Get <bool>("Endpoint.SendOnly"),
NServiceBusVersion = GitFlowVersion.MajorMinorPatch
}
);
var messageSession = new MessageSession(pipelineComponent.CreateRootContext(builder));
return(new StartableEndpoint(settings, builder, featureActivator, transportInfrastructure, receiveComponent, criticalError, messageSession));
}
#pragma warning disable CS1591 // 缺少对公共可见类型或成员“LeactosController.LeactosController(IMessageService, IUserService, MessageMapper, EmailHelper)”的 XML 注释
public LeactosController(IMessageService messageService, IUserService userService, MessageMapper mapperToMessageDTO, EmailHelper sendEmail)
#pragma warning restore CS1591 // 缺少对公共可见类型或成员“LeactosController.LeactosController(IMessageService, IUserService, MessageMapper, EmailHelper)”的 XML 注释
{
this.messageService = messageService;
this.userService = userService;
this.mapperToMessageDTO = mapperToMessageDTO;
this.sendEmail = sendEmail;
}
public CategoryService(ICategoryRepository categoryRepository)
{
_categoryRepository = categoryRepository;
_messageMapper = new MessageMapper();
}
protected JsonMessageSerializerTestBase(params Type[] messageTypes)
{
MessageMapper = new MessageMapper();
MessageMapper.Initialize(new[] { typeof(IA), typeof(A) }.Union(messageTypes));
}
void Initialize()
{
var pipelineSettings = settings.Get <PipelineSettings>();
hostingConfiguration.Container.RegisterSingleton <ReadOnlySettings>(settings);
featureComponent = new FeatureComponent(settings);
// This needs to happen here to make sure that features enabled state is present in settings so both
// IWantToRunBeforeConfigurationIsFinalized implementations and transports can check access it
featureComponent.RegisterFeatureEnabledStatusInSettings(hostingConfiguration);
ConfigRunBeforeIsFinalized(hostingConfiguration);
var transportConfiguration = TransportComponent.PrepareConfiguration(settings.Get <TransportComponent.Settings>());
var receiveConfiguration = BuildReceiveConfiguration(transportConfiguration);
var routingComponent = RoutingComponent.Initialize(
settings.Get <RoutingComponent.Configuration>(),
transportConfiguration,
receiveConfiguration,
settings.Get <Conventions>(),
pipelineSettings);
var messageMapper = new MessageMapper();
settings.Set <IMessageMapper>(messageMapper);
recoverabilityComponent = new RecoverabilityComponent(settings);
var featureConfigurationContext = new FeatureConfigurationContext(settings, hostingConfiguration.Container, pipelineSettings, routingComponent, receiveConfiguration);
featureComponent.Initalize(featureConfigurationContext);
hostingConfiguration.CreateHostInformationForV7BackwardsCompatibility();
recoverabilityComponent.Initialize(receiveConfiguration, hostingConfiguration);
sendComponent = SendComponent.Initialize(pipelineSettings, hostingConfiguration, routingComponent, messageMapper);
pipelineComponent = PipelineComponent.Initialize(pipelineSettings, hostingConfiguration);
hostingConfiguration.Container.ConfigureComponent(b => settings.Get <Notifications>(), DependencyLifecycle.SingleInstance);
receiveComponent = ReceiveComponent.Initialize(
settings.Get <ReceiveComponent.Configuration>(),
receiveConfiguration,
transportConfiguration,
pipelineComponent,
settings.ErrorQueueAddress(),
hostingConfiguration,
pipelineSettings);
installationComponent = InstallationComponent.Initialize(settings.Get <InstallationComponent.Configuration>(),
hostingConfiguration);
// The settings can only be locked after initializing the feature component since it uses the settings to store & share feature state.
// As well as all the other components have been initialized
settings.PreventChanges();
transportComponent = TransportComponent.Initialize(transportConfiguration, hostingConfiguration);
settings.AddStartupDiagnosticsSection("Endpoint",
new
{
Name = settings.EndpointName(),
SendOnly = settings.Get <bool>("Endpoint.SendOnly"),
NServiceBusVersion = GitVersionInformation.MajorMinorPatch
}
);
}
public void TestInterfaces()
{
var output = new MemoryStream();
var messageMapper = new MessageMapper();
messageMapper.Initialize(new[]
{
typeof(IA),
typeof(IAImpl)
});
var obj = messageMapper.CreateInstance <IA>(
x =>
{
x.S = "kalle";
x.I = 42;
x.Data = new byte[23];
x.B = new B
{
BString = "BOO",
C = new C
{
Cstr = "COO"
}
};
}
);
new Random().NextBytes(obj.Data);
var serializer = new JsonMessageSerializer(messageMapper);
serializer.Serialize(obj, output);
output.Position = 0;
var filename = $"{GetType().Name}.{MethodBase.GetCurrentMethod().Name}.txt";
File.WriteAllBytes(filename, output.ToArray());
output.Position = 0;
var result = serializer.Deserialize(output, new[]
{
typeof(IAImpl)
});
Assert.DoesNotThrow(() => output.Position = 0, "Stream should still be open");
Assert.IsNotEmpty(result);
Assert.That(result, Has.Length.EqualTo(1));
Assert.That(result[0], Is.AssignableTo(typeof(IA)));
var a = (IA)result[0];
Assert.AreEqual(a.Data, obj.Data);
Assert.AreEqual(42, a.I);
Assert.AreEqual("kalle", a.S);
Assert.IsNotNull(a.B);
Assert.AreEqual("BOO", a.B.BString);
Assert.AreEqual("COO", ((C)a.B.C).Cstr);
}
public void TestMany()
{
var messageMapper = new MessageMapper();
messageMapper.Initialize(new[]
{
typeof(IAImpl),
typeof(IA)
});
var serializer = new JsonMessageSerializer(messageMapper);
var xml = @"[{
$type: ""NServiceBus.Serializers.Json.Tests.IA, NServiceBus.Core.Tests"",
Data: ""rhNAGU4dr/Qjz6ocAsOs3wk3ZmxHMOg="",
S: ""kalle"",
I: 42,
B: {
BString: ""BOO"",
C: {
$type: ""NServiceBus.Serializers.Json.Tests.C, NServiceBus.Core.Tests"",
Cstr: ""COO""
}
}
}, {
$type: ""NServiceBus.Serializers.Json.Tests.IA, NServiceBus.Core.Tests"",
Data: ""AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="",
S: ""kalle"",
I: 42,
B: {
BString: ""BOO"",
C: {
$type: ""NServiceBus.Serializers.Json.Tests.C, NServiceBus.Core.Tests"",
Cstr: ""COO""
}
}
}]";
using (var stream = new MemoryStream())
{
var streamWriter = new StreamWriter(stream);
streamWriter.Write(xml);
streamWriter.Flush();
stream.Position = 0;
var result = serializer.Deserialize(stream, new[]
{
typeof(IAImpl)
});
Assert.IsNotEmpty(result);
Assert.That(result, Has.Length.EqualTo(2));
Assert.That(result[0], Is.AssignableTo(typeof(IA)));
var a = (IA) result[0];
Assert.AreEqual(23, a.Data.Length);
Assert.AreEqual(42, a.I);
Assert.AreEqual("kalle", a.S);
Assert.IsNotNull(a.B);
Assert.AreEqual("BOO", a.B.BString);
Assert.AreEqual("COO", ((C) a.B.C).Cstr);
}
}
public void TestInterfaces()
{
var mapper = new MessageMapper();
var serializer = SerializerFactory.Create <ISecondSerializableMessage>(mapper);
var o = mapper.CreateInstance <ISecondSerializableMessage>();
o.Id = Guid.NewGuid();
o.Age = 10;
o.Address = Guid.NewGuid().ToString();
o.Int = 7;
o.Name = "udi";
o.Uri = new Uri("http://www.UdiDahan.com/");
o.Risk = new Risk
{
Percent = 0.15D,
Annum = true,
Accuracy = 0.314M
};
o.Some = SomeEnum.B;
o.Start = DateTime.Now;
o.Duration = TimeSpan.Parse("-01:15:27.123");
o.Offset = DateTimeOffset.Now;
o.Lookup = new MyDictionary();
o.Lookup["1"] = "1";
o.Foos = new Dictionary <string, List <Foo> >();
o.Foos["foo1"] = new List <Foo>(new[]
{
new Foo
{
Name = "1",
Title = "1"
},
new Foo
{
Name = "2",
Title = "2"
}
});
o.Data = new byte[]
{
1,
2,
3,
4,
5,
4,
3,
2,
1
};
o.SomeStrings = new List <string>
{
"a",
"b",
"c"
};
o.ArrayFoos = new[]
{
new Foo
{
Name = "FooArray1",
Title = "Mr."
},
new Foo
{
Name = "FooAray2",
Title = "Mrs"
}
};
o.Bars = new[]
{
new Bar
{
Name = "Bar1",
Length = 1
},
new Bar
{
Name = "BAr2",
Length = 5
}
};
o.NaturalNumbers = new HashSet <int>(new[]
{
0,
1,
2,
3,
4,
5,
6,
7,
8,
9
});
o.Developers = new HashSet <string>(new[]
{
"Udi Dahan",
"Andreas Ohlund",
"Matt Burton",
"Jonathan Oliver et al"
});
o.Parent = mapper.CreateInstance <IFirstSerializableMessage>();
o.Parent.Name = "udi";
o.Parent.Age = 10;
o.Parent.Address = Guid.NewGuid().ToString();
o.Parent.Int = 7;
o.Parent.Name = "-1";
o.Parent.Risk = new Risk
{
Percent = 0.15D,
Annum = true,
Accuracy = 0.314M
};
o.Names = new List <IFirstSerializableMessage>();
for (var i = 0; i < number; i++)
{
var firstMessage = mapper.CreateInstance <IFirstSerializableMessage>();
o.Names.Add(firstMessage);
firstMessage.Age = 10;
firstMessage.Address = Guid.NewGuid().ToString();
firstMessage.Int = 7;
firstMessage.Name = i.ToString();
firstMessage.Risk = new Risk
{
Percent = 0.15D,
Annum = true,
Accuracy = 0.314M
};
}
o.MoreNames = o.Names.ToArray();
Time(o, serializer);
}
public void TestMany()
{
var messageMapper = new MessageMapper();
messageMapper.Initialize(new[]
{
typeof(IAImpl),
typeof(IA)
});
var serializer = new JsonMessageSerializer(messageMapper);
var xml = @"[{
$type: ""NServiceBus.Serializers.Json.Tests.IA, NServiceBus.Core.Tests"",
Data: ""rhNAGU4dr/Qjz6ocAsOs3wk3ZmxHMOg="",
S: ""kalle"",
I: 42,
B: {
BString: ""BOO"",
C: {
$type: ""NServiceBus.Serializers.Json.Tests.C, NServiceBus.Core.Tests"",
Cstr: ""COO""
}
}
}, {
$type: ""NServiceBus.Serializers.Json.Tests.IA, NServiceBus.Core.Tests"",
Data: ""AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="",
S: ""kalle"",
I: 42,
B: {
BString: ""BOO"",
C: {
$type: ""NServiceBus.Serializers.Json.Tests.C, NServiceBus.Core.Tests"",
Cstr: ""COO""
}
}
}]";
using (var stream = new MemoryStream())
{
var streamWriter = new StreamWriter(stream);
streamWriter.Write(xml);
streamWriter.Flush();
stream.Position = 0;
var result = serializer.Deserialize(stream, new[]
{
typeof(IAImpl)
});
Assert.IsNotEmpty(result);
Assert.That(result, Has.Length.EqualTo(2));
Assert.That(result[0], Is.AssignableTo(typeof(IA)));
var a = (IA)result[0];
Assert.AreEqual(23, a.Data.Length);
Assert.AreEqual(42, a.I);
Assert.AreEqual("kalle", a.S);
Assert.IsNotNull(a.B);
Assert.AreEqual("BOO", a.B.BString);
Assert.AreEqual("COO", ((C)a.B.C).Cstr);
}
}
public void Deserialize_message_without_concrete_implementation()
{
var messageMapper = new MessageMapper();
messageMapper.Initialize(new[]
{
typeof(ISuperMessageWithoutConcreteImpl)
});
var serializer = new JsonMessageSerializer(messageMapper);
using (var stream = new MemoryStream())
{
var msg = messageMapper.CreateInstance<ISuperMessageWithoutConcreteImpl>();
msg.SomeProperty = "test";
serializer.Serialize(msg, stream);
stream.Position = 0;
var result = (ISuperMessageWithoutConcreteImpl) serializer.Deserialize(stream, new[]
{
typeof(ISuperMessageWithoutConcreteImpl)
})[0];
Assert.AreEqual("test", result.SomeProperty);
}
}
public void Accept_Attributes_with_no_default_ctor_while_ctor_parameters_are_different_than_properties_of_custom_attribute()
{
var mapper = new MessageMapper();
mapper.Initialize(new[] { typeof(InterfaceWithCustomAttributeThatHasNoDefaultConstructorAndNoMatchingParameters) });
var instance = mapper.CreateInstance(typeof(InterfaceWithCustomAttributeThatHasNoDefaultConstructorAndNoMatchingParameters));
var attributes = instance.GetType().GetProperty("SomeProperty").GetCustomAttributes(typeof(CustomAttributeWithNoDefaultConstructorAndNoMatchingParameters), true);
var attr = (CustomAttributeWithNoDefaultConstructorAndNoMatchingParameters)attributes[0];
Assert.AreEqual(attr.Name, "Blah");
}
public void Queue_Manager_Test()
{
var clientManager = new PooledRedisClientManager();
clientManager.GetClient().FlushDb();
var manager = new QueueManager(new JsonSerializer(), clientManager, new QueueKeyNameProvider(false));
var messageMapper = new MessageMapper();
messageMapper.Initialize(new[] { typeof(TestMessage), typeof(TestEvent) });
var nsbSerializer = new JsonMessageSerializer(messageMapper);
var message = new TestMessage()
{
Name = "Bob"
};
var transportMessage = new TransportMessage()
{
Id = Guid.NewGuid().ToString("N"),
MessageIntent = MessageIntentEnum.Send,
Headers = new Dictionary <string, string>()
};
transportMessage.Headers["NServiceBus.FailedQ"] = "original";
using (var ms = new MemoryStream())
{
nsbSerializer.Serialize(new[] { message }, ms);
transportMessage.Body = ms.ToArray();
}
var errorAddress = Address.Parse("error");
manager.SendMessageToQueue(transportMessage, errorAddress);
var messageCount = manager.GetMessageCount(errorAddress);
var messages = manager.GetAllMessages(errorAddress);
Assert.IsTrue(messages.Count == 1);
Assert.IsTrue(messages[0].Id == transportMessage.Id);
Assert.IsTrue(messageCount == 1);
var queues = manager.GetAllQueues();
Assert.IsTrue(queues.Count == 1);
manager.ReturnAllMessagesToSourceQueue(errorAddress);
var queues2 = manager.GetAllQueues();
Assert.IsTrue(queues2.Count(o => o.Queue == "original") > 0);
manager.DeleteQueue(Address.Parse("original"));
var queues3 = manager.GetAllQueues();
Assert.IsTrue(queues3.Count == 0);
}
public void Serialize_message_without_concrete_implementation()
{
var messageMapper = new MessageMapper();
messageMapper.Initialize(new[]
{
typeof(ISuperMessageWithoutConcreteImpl)
});
var serializer = new JsonMessageSerializer(messageMapper);
using (var stream = new MemoryStream())
{
serializer.Serialize(messageMapper.CreateInstance<ISuperMessageWithoutConcreteImpl>(), stream);
stream.Position = 0;
var result = new StreamReader(stream).ReadToEnd();
Assert.That(!result.Contains("$type"), result);
Assert.That(result.Contains("SomeProperty"), result);
}
}
private object Process(XmlNode node, object parent)
{
string name = node.Name;
string typeName = defaultNameSpace + "." + name;
if (name.Contains(":"))
{
int colonIndex = node.Name.IndexOf(":");
name = name.Substring(colonIndex + 1);
string prefix = node.Name.Substring(0, colonIndex);
string ns = prefixesToNamespaces[prefix];
typeName = ns.Substring(nameSpace.LastIndexOf("/") + 1) + "." + name;
}
if (name.Contains("NServiceBus."))
{
typeName = name;
}
if (parent != null)
{
if (parent is IEnumerable)
{
if (parent.GetType().IsArray)
{
return(GetObjectOfTypeFromNode(parent.GetType().GetElementType(), node));
}
var args = parent.GetType().GetGenericArguments();
if (args.Length == 1)
{
return(GetObjectOfTypeFromNode(args[0], node));
}
}
PropertyInfo prop = parent.GetType().GetProperty(name);
if (prop != null)
{
return(GetObjectOfTypeFromNode(prop.PropertyType, node));
}
}
Type t = MessageMapper.GetMappedTypeFor(typeName);
if (t == null)
{
logger.Debug("Could not load " + typeName + ". Trying base types...");
foreach (Type baseType in messageBaseTypes)
{
try
{
logger.Debug("Trying to deserialize message to " + baseType.FullName);
return(GetObjectOfTypeFromNode(baseType, node));
}
// ReSharper disable EmptyGeneralCatchClause
catch { } // intentionally swallow exception
}
// ReSharper restore EmptyGeneralCatchClause
throw new TypeLoadException("Could not handle type '" + typeName + "'.");
}
return(GetObjectOfTypeFromNode(t, node));
}
public void Generated_type_should_preserve_namespace_to_make_it_easier_for_users_to_define_custom_conventions()
{
var mapper = new MessageMapper();
mapper.Initialize(new[] { typeof(InterfaceToGenerate) });
Assert.AreEqual(typeof(InterfaceToGenerate).Namespace, mapper.CreateInstance(typeof(InterfaceToGenerate)).GetType().Namespace);
}
/// <summary>
/// Serializes the given messages to the given stream.
/// </summary>
/// <param name="messages"></param>
/// <param name="stream"></param>
public void Serialize(IMessage[] messages, Stream stream)
{
namespacesToPrefix = new Dictionary <string, string>();
namespacesToAdd = new List <Type>();
var namespaces = GetNamespaces(messages, MessageMapper);
for (int i = 0; i < namespaces.Count; i++)
{
string prefix = "q" + i;
if (i == 0)
{
prefix = "";
}
if (namespaces[i] != null)
{
namespacesToPrefix[namespaces[i]] = prefix;
}
}
var messageBuilder = new StringBuilder();
foreach (var m in messages)
{
var t = MessageMapper.GetMappedTypeFor(m.GetType());
WriteObject(t.Name, t, m, messageBuilder);
}
var builder = new StringBuilder();
List <string> baseTypes = GetBaseTypes(messages, MessageMapper);
builder.AppendLine("<?xml version=\"1.0\" ?>");
builder.Append("<Messages xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"");
for (int i = 0; i < namespaces.Count; i++)
{
string prefix = "q" + i;
if (i == 0)
{
prefix = "";
}
builder.AppendFormat(" xmlns{0}=\"{1}/{2}\"", (prefix != "" ? ":" + prefix : prefix), nameSpace, namespaces[i]);
}
foreach (var type in namespacesToAdd)
{
builder.AppendFormat(" xmlns:{0}=\"{1}\"", type.Name.ToLower(), type.Name);
}
for (int i = 0; i < baseTypes.Count; i++)
{
string prefix = BASETYPE;
if (i != 0)
{
prefix += i;
}
builder.AppendFormat(" xmlns:{0}=\"{1}\"", prefix, baseTypes[i]);
}
builder.Append(">\n");
builder.Append(messageBuilder.ToString());
builder.AppendLine("</Messages>");
byte[] buffer = Encoding.UTF8.GetBytes(builder.ToString());
stream.Write(buffer, 0, buffer.Length);
}
public void Accept_attributes_with_value_attribute()
{
var mapper = new MessageMapper();
mapper.Initialize(new[] { typeof(IMyEventWithAttributeWithBoolProperty) });
var instance = mapper.CreateInstance(typeof(IMyEventWithAttributeWithBoolProperty));
var attributes = instance.GetType().GetProperty("EventId").GetCustomAttributes(typeof(CustomAttributeWithValueProperties), true);
var attr = attributes[0] as CustomAttributeWithValueProperties;
Assert.AreEqual(attr != null && attr.FlagIsSet, true);
if (attr != null) Assert.AreEqual(attr.MyAge, 21);
}
public CatalogueService(IProductRepository productRepository) //Constracter
{
_productRepository = productRepository;
_messageMapper = new MessageMapper();
}
protected JsonMessageSerializerTestBase()
{
MessageMapper = new MessageMapper();
MessageMapper.Initialize(new[] { typeof(IA), typeof(A) });
}
protected void ReceiveMessage <T>(T message, IDictionary <string, string> headers = null, MessageMapper mapper = null)
{
RegisterMessageType <T>();
var messageToReceive = Helpers.Serialize(message, mapper: mapper);
if (headers != null)
{
foreach (var header in headers)
{
messageToReceive.Headers[header.Key] = header.Value;
}
}
ReceiveMessage(messageToReceive);
}
public void Deserialize_message_with_concrete_implementation_and_interface()
{
var map = new[]
{
typeof(SuperMessageWithConcreteImpl),
typeof(ISuperMessageWithConcreteImpl)
};
var messageMapper = new MessageMapper();
messageMapper.Initialize(map);
var serializer = new JsonMessageSerializer(messageMapper);
using (var stream = new MemoryStream())
{
var msg = new SuperMessageWithConcreteImpl
{
SomeProperty = "test"
};
serializer.Serialize(msg, stream);
stream.Position = 0;
var result = (ISuperMessageWithConcreteImpl) serializer.Deserialize(stream, map)[0];
Assert.IsInstanceOf<SuperMessageWithConcreteImpl>(result);
Assert.AreEqual("test", result.SomeProperty);
}
}
void Initialize()
{
containerComponent.ContainerConfiguration.RegisterSingleton <ReadOnlySettings>(settings);
RegisterCriticalErrorHandler();
var concreteTypes = settings.GetAvailableTypes()
.Where(IsConcrete)
.ToList();
featureComponent = new FeatureComponent(settings);
// This needs to happen here to make sure that features enabled state is present in settings so both
// IWantToRunBeforeConfigurationIsFinalized implementations and transports can check access it
featureComponent.RegisterFeatureEnabledStatusInSettings(concreteTypes);
ConfigRunBeforeIsFinalized(concreteTypes);
transportInfrastructure = InitializeTransportComponent();
var receiveConfiguration = BuildReceiveConfiguration(transportInfrastructure);
var routingComponent = new RoutingComponent(settings);
routingComponent.Initialize(transportInfrastructure, pipelineComponent, receiveConfiguration);
var messageMapper = new MessageMapper();
settings.Set <IMessageMapper>(messageMapper);
pipelineComponent.AddRootContextItem <IMessageMapper>(messageMapper);
recoverabilityComponent = new RecoverabilityComponent(settings);
var featureConfigurationContext = new FeatureConfigurationContext(settings, containerComponent.ContainerConfiguration, pipelineComponent.PipelineSettings, routingComponent, receiveConfiguration);
featureComponent.Initalize(containerComponent, featureConfigurationContext);
//The settings can only be locked after initializing the feature component since it uses the settings to store & share feature state.
settings.PreventChanges();
recoverabilityComponent.Initialize(receiveConfiguration);
pipelineComponent.Initialize(containerComponent);
containerComponent.ContainerConfiguration.ConfigureComponent(b => settings.Get <Notifications>(), DependencyLifecycle.SingleInstance);
var eventAggregator = new EventAggregator(settings.Get <NotificationSubscriptions>());
pipelineComponent.AddRootContextItem <IEventAggregator>(eventAggregator);
var shouldRunInstallers = settings.GetOrDefault <bool>("Installers.Enable");
if (shouldRunInstallers)
{
RegisterInstallers(concreteTypes);
}
settings.AddStartupDiagnosticsSection("Endpoint",
new
{
Name = settings.EndpointName(),
SendOnly = settings.Get <bool>("Endpoint.SendOnly"),
NServiceBusVersion = GitVersionInformation.MajorMinorPatch
}
);
queueBindings = settings.Get <QueueBindings>();
receiveComponent = CreateReceiveComponent(receiveConfiguration, transportInfrastructure, pipelineComponent, queueBindings, eventAggregator);
}
public SmartMeterService(ISmartMeterRepository smartmeterRepository)
{
_smartmeterRepository = smartmeterRepository;
_messageMapper = new MessageMapper();
}
