static async Task AsyncMain()
{
LogManager.Use <DefaultFactory>().Level(LogLevel.Error);
#region Program
Logger.WriteLine("Starting configuration");
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.StartupShutdown");
busConfiguration.EnableInstallers();
busConfiguration.EnableFeature <MyFeature>();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.SendFailedMessagesTo("error");
Logger.WriteLine("Calling Bus.Create");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
Logger.WriteLine("Calling IEndpointInstance.CreateBusContext");
IBusContext busContext = endpoint.CreateBusContext();
//simulate some bus activity
Thread.Sleep(500);
Logger.WriteLine("Bus is processing messages");
}
finally
{
Logger.WriteLine("Calling IEndpointInstance.Stop");
await endpoint.Stop();
}
Logger.WriteLine("Finished");
#endregion
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.MessageMutators");
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.SendFailedMessagesTo("error");
#region ComponentRegistartion
busConfiguration.RegisterComponents(components =>
{
components.ConfigureComponent <ValidationMessageMutator>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent <TransportMessageCompressionMutator>(DependencyLifecycle.InstancePerCall);
});
#endregion
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
await Runner.Run(busContext);
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
LogManager.Use <DefaultFactory>()
.Level(LogLevel.Info);
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.FullDuplex.Server");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.EnableInstallers();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
#region logging
DefaultFactory defaultFactory = LogManager.Use <DefaultFactory>();
defaultFactory.Level(LogLevel.Fatal);
#endregion
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.Logging.Default");
busConfiguration.SendFailedMessagesTo("error");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
await busContext.SendLocal(new MyMessage());
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
#region non-transactional
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.UseTransport <MsmqTransport>()
.Transactions(TransportTransactionMode.None);
#endregion
busConfiguration.EndpointName("Samples.MessageDurability.Sender");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
await busContext.Send("Samples.MessageDurability.Receiver", new MyMessage());
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.FaultTolerance.Server");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.SendFailedMessagesTo("error");
// To disable second level retries(SLR), uncomment the following line. SLR is enabled by default.
// busConfiguration.DisableFeature<SecondLevelRetries>();
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
#region self-hosting
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.SelfHosting");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
Console.WriteLine("\r\nBus created and configured; press any key to stop program\r\n");
await busContext.SendLocal(new MyMessage());
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
#endregion
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.PipelineStream.Sender");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.SendFailedMessagesTo("error");
#region configure-stream-storage
busConfiguration.SetStreamStorageLocation("..\\..\\..\\storage");
#endregion
busConfiguration.EnableInstallers();
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
await Run(busContext);
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
#region ContainerConfiguration
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.Castle");
WindsorContainer container = new WindsorContainer();
container.Register(Component.For <MyService>().Instance(new MyService()));
busConfiguration.UseContainer <WindsorBuilder>(c => c.ExistingContainer(container));
#endregion
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.SendFailedMessagesTo("error");
busConfiguration.EnableInstallers();
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
await busContext.SendLocal(new MyMessage());
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
#region ConfigureLogging
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.Logging.Default");
//Note that no config is required in version 5 and higher since logging is enabled by default
#endregion
busConfiguration.SendFailedMessagesTo("error");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
await busContext.SendLocal(new MyMessage());
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.ComplexSagaFindingLogic");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
await busContext.SendLocal(new StartOrder
{
OrderId = "123"
});
await busContext.SendLocal(new StartOrder
{
OrderId = "456"
});
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.Unobtrusive.Client");
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.UseDataBus <FileShareDataBus>()
.BasePath(@"..\..\..\DataBusShare\");
busConfiguration.RijndaelEncryptionService("gdDbqRpqdRbTs3mhdZh8qCaDaxJXl+e7");
busConfiguration.SendFailedMessagesTo("error");
busConfiguration.ApplyCustomConventions();
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
await CommandSender.Start(busContext);
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
#region ContainerConfiguration
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.Spring");
GenericApplicationContext applicationContext = new GenericApplicationContext();
applicationContext.ObjectFactory.RegisterSingleton("MyService", new MyService());
busConfiguration.UseContainer <SpringBuilder>(c => c.ExistingApplicationContext(applicationContext));
#endregion
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
await busContext.SendLocal(new MyMessage());
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.MessageBodyEncryption.Endpoint1");
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.RegisterMessageEncryptor();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
CompleteOrder completeOrder = new CompleteOrder
{
CreditCard = "123-456-789"
};
await busContext.Send("Samples.MessageBodyEncryption.Endpoint2", completeOrder);
Console.WriteLine("Message sent");
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
#region config
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.Serialization.Xml");
// this is optional since Xml is the default serializer
busConfiguration.UseSerialization <XmlSerializer>();
// register the mutator so the the message on the wire is written
busConfiguration.RegisterComponents(components =>
{
components.ConfigureComponent <MessageBodyWriter>(DependencyLifecycle.InstancePerCall);
});
#endregion
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.EnableInstallers();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
#region message
CreateOrder message = new CreateOrder
{
OrderId = 9,
Date = DateTime.Now,
CustomerId = 12,
OrderItems = new List <OrderItem>
{
new OrderItem
{
ItemId = 6,
Quantity = 2
},
new OrderItem
{
ItemId = 5,
Quantity = 4
},
}
};
await busContext.SendLocal(message);
#endregion
Console.WriteLine("Order Sent");
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
#region multi-hosting
IEndpointInstance endpoint1 = null;
IEndpointInstance endpoint2 = null;
try
{
endpoint1 = await StartInstance1();
endpoint2 = await StartInstance2();
Console.WriteLine("Press '1' to send a message from Instance1 to Instance2");
Console.WriteLine("Press '2' to send a message from Instance2 to Instance1");
Console.WriteLine("Press any key to exit");
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
Console.WriteLine();
if (key.Key == ConsoleKey.D1)
{
await endpoint1.CreateBusContext().Send("Samples.MultiHosting.Instance2", new MyMessage());
continue;
}
if (key.Key == ConsoleKey.D2)
{
await endpoint2.CreateBusContext().Send("Samples.MultiHosting.Instance1", new MyMessage());
continue;
}
return;
}
}
finally
{
if (endpoint1 != null)
{
endpoint1.Stop().GetAwaiter().GetResult();
}
if (endpoint2 != null)
{
endpoint2.Stop().GetAwaiter().GetResult();
}
}
#endregion
}
static async Task AsyncMain()
{
LogManager.Use <DefaultFactory>()
.Level(LogLevel.Info);
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.FullDuplex.Client");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.EnableInstallers();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
Console.WriteLine("Press enter to send a message");
Console.WriteLine("Press any key to exit");
#region ClientLoop
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
Console.WriteLine();
if (key.Key != ConsoleKey.Enter)
{
return;
}
Guid guid = Guid.NewGuid();
Console.WriteLine("Requesting to get data by id: {0}", guid.ToString("N"));
RequestDataMessage message = new RequestDataMessage
{
DataId = guid,
String = "String property value"
};
await busContext.Send("Samples.FullDuplex.Server", message);
}
#endregion
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
#region ConfigureLog4Net
PatternLayout layout = new PatternLayout
{
ConversionPattern = "%d [%t] %-5p %c [%x] - %m%n"
};
layout.ActivateOptions();
ConsoleAppender consoleAppender = new ConsoleAppender
{
Threshold = Level.Info,
Layout = layout
};
// Note that ActivateOptions is required in NSB 5 and above
consoleAppender.ActivateOptions();
BasicConfigurator.Configure(consoleAppender);
#endregion
#region UseConfig
LogManager.Use <Log4NetFactory>();
// Then continue with your bus configuration
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.Logging.Log4NetCustom");
#endregion
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
await busContext.SendLocal(new MyMessage());
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncRun()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.Headers");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.SendFailedMessagesTo("error");
busConfiguration.RegisterComponents(components =>
{
components.ConfigureComponent <MutateIncomingMessages>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent <MutateIncomingTransportMessages>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent <MutateOutgoingMessages>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent <MutateOutgoingTransportMessages>(DependencyLifecycle.InstancePerCall);
});
#region global-all-outgoing
busConfiguration.AddHeaderToAllOutgoingMessages("AllOutgoing", "ValueAllOutgoing");
#endregion
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
#region sending
MyMessage myMessage = new MyMessage();
await busContext.SendLocal(myMessage);
#endregion
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
#region ConfigureNLog
LoggingConfiguration config = new LoggingConfiguration();
ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget
{
Layout = "${level}|${logger}|${message}${onexception:${newline}${exception:format=tostring}}"
};
config.AddTarget("console", consoleTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, consoleTarget));
LogManager.Configuration = config;
#endregion
#region UseConfig
NServiceBus.Logging.LogManager.Use <NLogFactory>();
// Then continue with your BusConfiguration
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.Logging.NLogCustom");
#endregion
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
await busContext.SendLocal(new MyMessage());
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.DataBus.Sender");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.UseDataBus <FileShareDataBus>().BasePath(BasePath);
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.EnableInstallers();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
Console.WriteLine("Press 'D' to send a databus large message");
Console.WriteLine("Press 'N' to send a normal large message exceed the size limit and throw");
Console.WriteLine("Press any other key to exit");
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
Console.WriteLine();
if (key.Key == ConsoleKey.N)
{
await SendMessageTooLargePayload(busContext);
continue;
}
if (key.Key == ConsoleKey.D)
{
await SendMessageLargePayload(busContext);
continue;
}
return;
}
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncStart()
{
var busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Store.ECommerce");
busConfiguration.PurgeOnStartup(true);
busConfiguration.ApplyCommonConfiguration();
busConfiguration.SendFailedMessagesTo("error");
Endpoint = await NServiceBus.Endpoint.Start(busConfiguration);
BusContext = Endpoint.CreateBusContext();
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.PerfCounters");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.SendFailedMessagesTo("error");
#region enable-counters
busConfiguration.EnableCriticalTimePerformanceCounter();
busConfiguration.EnableSLAPerformanceCounter(TimeSpan.FromSeconds(100));
#endregion
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
Console.WriteLine("Press enter to send 10 messages with random sleep");
Console.WriteLine("Press any key to exit");
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
Console.WriteLine();
if (key.Key != ConsoleKey.Enter)
{
break;
}
for (int i = 0; i < 10; i++)
{
await busContext.SendLocal(new MyMessage());
}
}
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.Encryption.Endpoint1");
busConfiguration.RijndaelEncryptionService();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
MessageWithSecretData message = new MessageWithSecretData
{
Secret = "betcha can't guess my secret",
SubProperty = new MySecretSubProperty
{
Secret = "My sub secret"
},
CreditCards = new List <CreditCardDetails>
{
new CreditCardDetails
{
ValidTo = DateTime.UtcNow.AddYears(1),
Number = "312312312312312"
},
new CreditCardDetails
{
ValidTo = DateTime.UtcNow.AddYears(2),
Number = "543645546546456"
}
}
};
await busContext.Send("Samples.Encryption.Endpoint2", message);
Console.WriteLine("MessageWithSecretData sent. Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
LogManager.Use <DefaultFactory>()
.Level(LogLevel.Warn);
#region DisableSLR
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.ErrorHandling.WithoutSLR");
busConfiguration.DisableFeature <SecondLevelRetries>();
#endregion
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.EnableInstallers();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
Console.WriteLine("Press enter to send a message that will throw an exception.");
Console.WriteLine("Press any key to exit");
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
if (key.Key != ConsoleKey.Enter)
{
return;
}
MyMessage m = new MyMessage
{
Id = Guid.NewGuid()
};
await busContext.SendLocal(m);
}
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.Versioning.V2Publisher");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.UsePersistence <MsmqPersistence, StorageType.Subscriptions>();
busConfiguration.EnableInstallers();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
Console.WriteLine("Press enter to publish a message");
Console.WriteLine("Press any key to exit");
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
Console.WriteLine();
if (key.Key != ConsoleKey.Enter)
{
return;
}
await busContext.Publish <V2.Messages.ISomethingHappened>(sh =>
{
sh.SomeData = 1;
sh.MoreInfo = "It's a secret.";
});
Console.WriteLine("Published event.");
}
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.MultiSerializer.Receiver");
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.EnableInstallers();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.MultiSerializer.Sender");
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.EnableInstallers();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
await Run(busContext);
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Store.Sales");
busConfiguration.ApplyCommonConfiguration();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.FaultTolerance.Client");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
Console.WriteLine("Press enter to send a message");
Console.WriteLine("Press any key to exit");
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
if (key.Key != ConsoleKey.Enter)
{
return;
}
Guid id = Guid.NewGuid();
await busContext.Send("Samples.FaultTolerance.Server", new MyMessage
{
Id = id
});
Console.WriteLine("Sent a new message with id: {0}", id.ToString("N"));
}
}
finally
{
await endpoint.Stop();
}
}