private static void Main(string[] args)
{
_encrypt = true;
_compress = true;
var jsonSer = new JsonSerialization();
var xmlSer = new XmlSerialization();
var binSer = new BinarySerializer();
var cert = new X509Certificate2(File.ReadAllBytes(Path.GetFullPath(@"C:\Users\" + Environment.UserName + @"\Desktop\test.pfx")), "Password");
_listener = new SimpleSocketTcpSslListener(cert);
// _listener = new SimpleSocketTcpListener();
_listener.Timeout = new TimeSpan(0, 5, 0);
_listener.ObjectSerializer = jsonSer;
_listener.AllowReceivingFiles = true;
_messageAContract = new MessageA("MessageAHeader");
_listener.AddMessageContract(_messageAContract);
_messageAContract.OnMessageReceived += MessageAContractOnOnMessageReceived;
BindEvents();
_listener.StartListening(13000);
while (true)
{
Options();
WriteLine("Press any key to continue...");
System.Console.Read();
System.Console.Clear();
}
}
private static void Main(string[] args)
{
_encrypt = false;
_client = new AsyncSocketClient {
AllowReceivingFiles = true
};
//Create the MessageContract implementation and add to the client
_messageAContract = new MessageA("MessageAHeader");
_client.AddMessageContract(_messageAContract);
//Bind MessageContract Event
_messageAContract.OnMessageReceived += MessageAContractOnOnMessageReceived;
BindEvents();
_client.StartClient("127.0.0.1", 13000);
while (true)
{
Options();
WriteLine("Press any key to continue...");
System.Console.Read();
System.Console.Clear();
}
}
public IEnumerable <MessageC> EEnumerate(MessageA message)
{
Add(message);
yield return(new MessageC());
yield return(new MessageC());
}
private static void Main(string[] args)
{
_encrypt = false;
_listener = new AsyncSocketListener {
AllowReceivingFiles = true
};
_messageAContract = new MessageA("MessageAHeader");
_listener.AddMessageContract(_messageAContract);
_messageAContract.OnMessageReceived += MessageAContractOnOnMessageReceived;
BindEvents();
_listener.StartListening(13000);
while (true)
{
Options();
WriteLine("Press any key to continue...");
System.Console.Read();
System.Console.Clear();
}
}
private static void Main(string[] args)
{
_encrypt = false;
_compress = false;
var xmlSer = new XmlSerialization();
var binSer = new BinarySerializer();
_listener = new SimpleSocketTcpListener();
//_listener = new SimpleSocketTcpSslListener(@"PATH\TO\CERT.pfx","Password");
_listener.ObjectSerializer = binSer;
_listener.AllowReceivingFiles = true;
_messageAContract = new MessageA("MessageAHeader");
_listener.AddMessageContract(_messageAContract);
_messageAContract.OnMessageReceived += MessageAContractOnOnMessageReceived;
BindEvents();
_listener.StartListening(13000);
while (true)
{
Options();
WriteLine("Press any key to continue...");
System.Console.Read();
System.Console.Clear();
}
}
static async Task Main()
{
//required to prevent possible occurrence of .NET Core issue https://github.com/dotnet/coreclr/issues/12668
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
Console.Title = "Samples.CustomTransport.Endpoint1";
var endpointConfiguration = new EndpointConfiguration("Samples.CustomTransport.Endpoint1");
#region UseDefinition
endpointConfiguration.UseTransport <FileTransport>();
#endregion
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.DisableFeature <TimeoutManager>();
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
#region StartMessageInteraction
var messageA = new MessageA();
await endpointInstance.Send("Samples.CustomTransport.Endpoint2", messageA)
.ConfigureAwait(false);
#endregion
Console.WriteLine("MessageA sent. Press any key to exit");
Console.ReadKey();
await endpointInstance.Stop()
.ConfigureAwait(false);
}
private static async Task AsyncMain()
{
Console.Title = "NServiceBus.Transport.Email.Demo.Sender";
var demoSettings = ConsoleHelper.LoadDemoSettings();
var endpointConfiguration = new EndpointConfiguration("NSB-Sender-Endpoint");
endpointConfiguration.UseTransport <EmailTransport>().GetSettings().ConfigureEmailTransport(demoSettings);
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.DisableFeature <TimeoutManager>();
endpointConfiguration.UseSerialization <NewtonsoftSerializer>();
var endpointInstance = await Endpoint.Start(endpointConfiguration);
var messageA = new MessageA();
var receiverEndpointName = $"NSB-Receiver-Endpoint@{demoSettings.ImapUser}";
await endpointInstance.Send(receiverEndpointName, messageA);
Console.WriteLine("MessageA sent to endpoint {0}. Press any key to exit", receiverEndpointName);
Console.ReadKey();
await endpointInstance.Stop();
}
public void GetMessagePartition()
{
// arrange
var publisherA = new ProducerSettings();
new ProducerBuilder <MessageA>(publisherA)
.PartitionProvider((m, t) => 10);
var publisherB = new ProducerSettings();
new ProducerBuilder <MessageB>(publisherB);
MbSettings.Producers.Add(publisherA);
MbSettings.Producers.Add(publisherB);
var msgA = new MessageA();
var msgB = new MessageB();
// act
var msgAPartition = KafkaMb.Value.Public_GetMessagePartition(msgA.GetType(), msgA, "topic1");
var msgBPartition = KafkaMb.Value.Public_GetMessagePartition(msgB.GetType(), msgB, "topic1");
// assert
msgAPartition.Should().Be(10);
msgBPartition.Should().Be(-1);
}
static async Task AsyncMain()
{
Console.Title = "Samples.CustomTransport.Endpoint1";
var endpointConfiguration = new EndpointConfiguration("Samples.CustomTransport.Endpoint1");
#region UseDefinition
endpointConfiguration.UseTransport<FileTransport>();
#endregion
endpointConfiguration.UsePersistence<InMemoryPersistence>();
endpointConfiguration.UseSerialization<JsonSerializer>();
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.DisableFeature<TimeoutManager>();
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
try
{
#region StartMessageInteraction
var messageA = new MessageA();
await endpointInstance.Send("Samples.CustomTransport.Endpoint2", messageA)
.ConfigureAwait(false);
#endregion
Console.WriteLine("MessageA sent. Press any key to exit");
Console.ReadKey();
}
finally
{
await endpointInstance.Stop()
.ConfigureAwait(false);
}
}
public void Should_be_able_to_autosubscribe_to_several_messages_in_one_consumer()
{
var interceptedSubscriptions = new List <Tuple <string, Delegate> >();
var busFake = new BusFake
{
InterceptSubscribe = (s, a) => interceptedSubscriptions.Add(new Tuple <string, Delegate>(s, a))
};
var autoSubscriber = new AutoSubscriber(busFake, "MyAppPrefix");
autoSubscriber.Subscribe(GetType().Assembly);
interceptedSubscriptions.Count.ShouldEqual(4);
interceptedSubscriptions.TrueForAll(i => i.Item2.Method.DeclaringType == typeof(DefaultMessageDispatcher)).ShouldBeTrue();
CheckSubscriptionsContains <MessageA>(interceptedSubscriptions, "MyAppPrefix:e8afeaac27aeba31a42dea8e4d05308e");
CheckSubscriptionsContains <MessageB>(interceptedSubscriptions, "MyExplicitId");
CheckSubscriptionsContains <MessageC>(interceptedSubscriptions, "MyAppPrefix:cf5f54ed13478763e2da2bb3c9487baa");
var messageADispatcher = (Action <MessageA>)interceptedSubscriptions.Single(x => x.Item2.GetType().GetGenericArguments()[0] == typeof(MessageA)).Item2;
var message = new MessageA {
Text = "Hello World"
};
messageADispatcher(message);
}
static async Task AsyncMain()
{
Console.Title = "Samples.CustomTransport.Endpoint1";
var endpointConfiguration = new EndpointConfiguration("Samples.CustomTransport.Endpoint1");
#region UseDefinition
endpointConfiguration.UseTransport <FileTransport>();
#endregion
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.DisableFeature <TimeoutManager>();
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
#region StartMessageInteraction
var messageA = new MessageA();
await endpointInstance.Send("Samples.CustomTransport.Endpoint2", messageA)
.ConfigureAwait(false);
#endregion
Console.WriteLine("MessageA sent. Press any key to exit");
Console.ReadKey();
await endpointInstance.Stop()
.ConfigureAwait(false);
}
private static async Task AsyncMain()
{
Console.Title = "FileSystem Transport: Application One";
var endpointConfigurationBuilder = new EndpointConfigurationBuilder();
var endpointConfiguration = endpointConfigurationBuilder.GetEndpointConfiguration <FileTransport>(Endpoints.EndpointOne, Endpoints.ErrorQueue);
endpointConfiguration.DisableFeature <TimeoutManager>();
var endpointInstance = await Endpoint.Start(endpointConfiguration).ConfigureAwait(false);
try
{
for (var i = 0; i < 100; i++)
{
var messageA = new MessageA();
await endpointInstance.Send(Endpoints.EndpointTwo, messageA).ConfigureAwait(false);
}
Console.WriteLine();
Console.WriteLine("MessageA sent. Press any key to exit");
Console.ReadKey();
}
finally
{
await endpointInstance.Stop().ConfigureAwait(false);
}
}
public void MessageWithoutLabelAttributeUsesTypeFullName()
{
var messageWithoutAttribute = new MessageA();
var msg = MessageBuilder.BuildMessage(messageWithoutAttribute);
Assert.Equal(typeof(MessageA).FullName, msg.Subject);
}
public async Task ClientReadsMessageFromQueue()
{
TestMqServer server = new TestMqServer();
server.Initialize(42801);
server.Start();
bool received = false;
MessageReader reader = MessageReader.JsonReader();
reader.On <MessageA>("ch-1", MessageA.ContentType, a => { received = true; });
TmqClient client = new TmqClient();
await client.ConnectAsync("tmq://localhost:42801");
Assert.True(client.IsConnected);
reader.Attach(client);
TmqResponseCode joined = await client.Join("ch-1", true);
Assert.Equal(TmqResponseCode.Ok, joined);
await Task.Delay(1000);
MessageA m = new MessageA("Msg-A");
MemoryStream ms = new MemoryStream();
await System.Text.Json.JsonSerializer.SerializeAsync(ms, m);
bool sent = await client.Push("ch-1", MessageA.ContentType, ms, false);
Assert.True(sent);
await Task.Delay(500);
Assert.True(received);
}
public void GetMessageKey()
{
// arrange
var producerA = new ProducerSettings();
new ProducerBuilder <MessageA>(producerA)
.KeyProvider((m, t) => m.Key);
var producerB = new ProducerSettings();
new ProducerBuilder <MessageB>(producerB);
MbSettings.Producers.Add(producerA);
MbSettings.Producers.Add(producerB);
var msgA = new MessageA();
var msgB = new MessageB();
// act
var msgAKey = KafkaMb.Value.Public_GetMessageKey(msgA.GetType(), msgA, "topic1");
var msgBKey = KafkaMb.Value.Public_GetMessageKey(msgB.GetType(), msgB, "topic1");
// assert
msgAKey.Should().BeSameAs(msgA.Key);
msgBKey.Should().BeNull();
}
public void Test_IRecipientGenerator_GeneratedRegistration()
{
var messenger = new StrongReferenceMessenger();
var recipient = new RecipientWithSomeMessages();
var messageA = new MessageA();
var messageB = new MessageB();
Action <IMessenger, object, int> registrator = Microsoft.Toolkit.Mvvm.Messaging.__Internals.__IMessengerExtensions.CreateAllMessagesRegistratorWithToken <int>(recipient);
registrator(messenger, recipient, 42);
Assert.IsTrue(messenger.IsRegistered <MessageA, int>(recipient, 42));
Assert.IsTrue(messenger.IsRegistered <MessageB, int>(recipient, 42));
Assert.IsNull(recipient.A);
Assert.IsNull(recipient.B);
messenger.Send(messageA, 42);
Assert.AreSame(recipient.A, messageA);
Assert.IsNull(recipient.B);
messenger.Send(messageB, 42);
Assert.AreSame(recipient.A, messageA);
Assert.AreSame(recipient.B, messageB);
}
public void Should_be_able_to_autosubscribe_with_async_to_several_messages_in_one_consumer()
{
var interceptedSubscriptions = new List <Tuple <string, Delegate> >();
var busFake = new BusFake
{
InterceptSubscribe = (s, a) => interceptedSubscriptions.Add(new Tuple <string, Delegate>(s, a))
};
var autoSubscriber = new AutoSubscriber(busFake, "MyAppPrefix");
autoSubscriber.SubscribeAsync(GetType().Assembly);
interceptedSubscriptions.Count.ShouldEqual(3);
interceptedSubscriptions.TrueForAll(i => i.Item2.Method.DeclaringType == typeof(DefaultAutoSubscriberMessageDispatcher)).ShouldBeTrue();
CheckSubscriptionsContains <MessageA>(interceptedSubscriptions, "MyAppPrefix:595a495413330ce1a7d03dd6a434b599");
CheckSubscriptionsContains <MessageB>(interceptedSubscriptions, "MyExplicitId");
CheckSubscriptionsContains <MessageC>(interceptedSubscriptions, "MyAppPrefix:e65118ba1611619fa7afb53dc916866e");
var messageADispatcher = (Func <MessageA, Task>)interceptedSubscriptions.Single(x => x.Item2.GetType().GetGenericArguments()[0] == typeof(MessageA)).Item2;
var message = new MessageA {
Text = "Hello World"
};
messageADispatcher(message);
MyAsyncConsumer.MessageAText.ShouldEqual("Hello World");
}
public async Task Should_have_received_the_message()
{
_message = new MessageA();
await Bus.Publish(_message);
await _consumer.Task;
}
public void DispatchTest()
{
IContainer container = CreateContainer();
IMessage messageA = new MessageA();
DispatchMessage(container, messageA);
}
public async Task Should_have_received_the_message()
{
_message = new MessageA();
await Bus.Publish(_message);
await _consumer.Task;
}
public async Task Should_receive_the_proper_message_as_a_with_request_id()
{
Task <ConsumeContext <MessageA> > handler = SubscribeHandler <MessageA>(x => x.RequestId.HasValue);
var message = new MessageA();
await BusSendEndpoint.Send(message, Pipe.New <SendContext>(x => x.UseExecute(c => c.RequestId = NewId.NextGuid())));
await handler;
}
public async Task Should_receive_the_proper_message_as_a()
{
Task <ConsumeContext <MessageA> > handler = SubscribeHandler <MessageA>();
var message = new MessageA();
await BusSendEndpoint.Send(message);
await handler;
}
public async Task Should_receive_the_interface_of_the_message()
{
Task <ConsumeContext <IMessageA> > handler = SubscribeHandler <IMessageA>();
var message = new MessageA();
await BusSendEndpoint.Send(message);
await handler;
}
public async Task Should_receive_the_proper_message_type()
{
Task<ConsumeContext<MessageA>> handler = SubscribeHandler<MessageA>();
object message = new MessageA();
await BusSendEndpoint.Send(message, typeof(MessageA));
await handler;
}
public async Task Should_receive_the_proper_message_type()
{
Task <ConsumeContext <MessageA> > handler = SubscribeHandler <MessageA>();
object message = new MessageA();
await BusSendEndpoint.Send(message, typeof(MessageA));
await handler;
}
public async Task Should_receive_the_proper_message_as_a_with_request_id()
{
Task<ConsumeContext<MessageA>> handler = SubscribeHandler<MessageA>(x => x.RequestId.HasValue);
var message = new MessageA();
await BusSendEndpoint.Send(message, Pipe.New<SendContext>(x => x.UseExecute(c => c.RequestId = NewId.NextGuid())));
await handler;
}
public async Task Should_receive_the_interface_of_the_message()
{
Task<ConsumeContext<IMessageA>> handler = SubscribeHandler<IMessageA>();
var message = new MessageA();
await BusSendEndpoint.Send(message);
await handler;
}
public async Task Should_receive_the_proper_message_as_a()
{
Task<ConsumeContext<MessageA>> handler = SubscribeHandler<MessageA>();
var message = new MessageA();
await BusSendEndpoint.Send(message);
await handler;
}
public void Reset()
{
_c.Dispose();
MessageA.Reset();
MessageB.Reset();
MessageC.Reset();
_aCount = 0;
_bCount = 0;
_cCount = 0;
}
public void Should_use_converter_for_serialization()
{
var obj = new MessageA {
Value = "Joe"
};
var result = SerializeAndReturn(obj);
result.Value.ShouldBe("Monster");
}
public void Go()
{
var a = new MessageA();
var b = new MessageB();
var router = new MessageRouter();
router.Route(a);
router.Route(b);
}
public void HandleWithNoInterceptor()
{
var proxy = new MessageHandlerProxy <MessageA>(new MessageHandler1(), null);
var message = new MessageA {
Id = Guid.NewGuid().ToString(), BusinessKey = "Key1"
};
var ctx = new MockupMessageContext();
proxy.HandleAsync(message, ctx).Wait();
Assert.Equal($"MessageA_{message.Id}", ctx.GetResult());
}
public void TestMethod()
{
var processor = container.Resolve <MessageReceiver>();
MessageA ma = new MessageA();
MessageB mb = new MessageB();
processor.ReceiveMessage(ma);
processor.ReceiveMessage(mb);
Assert.AreEqual(ma.Handled, true);
Assert.AreEqual(mb.Handled, true);
}
public void CreateHandlerAUsingClosingTest()
{
IContainer container = CreateContainer();
MessageA messageA = new MessageA();
var handler = GetHandlerFor(container, messageA);
handler.Should().BeOfType <MessageAHandler>();
handler.Handle(messageA);
}
public void Default_setup_routes_the_message_correctly()
{
var sub = new SubscriptionThatFakesHandles <MessageA>();
var b = BusSetup
.StartWith <Conservative>(cb => cb.AddSubscription(sub))
.Construct();
var messageA = new MessageA();
b.Publish(messageA);
sub.PushCalls.ShouldBeEqualTo(1);
}
static void Main(string[] args)
{
MessageA messageA = new MessageA() { Element = "A" };
messageA.MyMethod();
MessageB messageB = new MessageB() { Element = "B" };
messageB.MyMethod();
messageB.MySpecificMethod();
MessageC message = new MessageC() { Element = "C" };
message.MyMethod();
Console.ReadLine();
}
public async Task Should_receive_the_proper_message_as_a_with_request_id()
{
Task<ConsumeContext<MessageA>> handler = SubscribeHandler<MessageA>(x => x.RequestId.HasValue);
var requestId = NewId.NextGuid();
var message = new MessageA();
await BusSendEndpoint.Send(message, c => c.RequestId = requestId);
var consumeContext = await handler;
consumeContext.RequestId.ShouldBe(requestId);
}
public void Should_use_converter_for_serialization()
{
var obj = new MessageA {Value = "Joe"};
MessageA result = SerializeAndReturn(obj);
result.Value.ShouldBe("Monster");
}
public async Task Should_receive_the_proper_message_without_type()
{
Task<ConsumeContext<MessageA>> handler = SubscribeHandler<MessageA>();
var requestId = NewId.NextGuid();
object message = new MessageA();
await BusSendEndpoint.Send(message, (SendContext context) => context.RequestId = requestId);
var consumeContext = await handler;
consumeContext.RequestId.ShouldBe(requestId);
}
