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);
}
public MessageB Update(MessageB addComment)
{
var entity = db.MessageBs.Attach(addComment);
entity.State = EntityState.Modified;
return(addComment);
}
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 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 IActionResult OnGet(int messageId)
{
messageD = listsData.GetById(messageId);
if (messageD == null)
{
return(RedirectToPage("./NotFound"));
}
return(Page());
}
public void Should_use_converter_for_deserialization()
{
var obj = new MessageB {
Value = "Joe"
};
var result = SerializeAndReturn(obj);
result.Value.ShouldBe("Monster");
}
public void Handle <T>(T args)
{
_builder.Append("~A~");
var msg = new MessageB {
TextB = "~B~"
};
_innerHandler.Handle(msg);
}
public void Go()
{
var a = new MessageA();
var b = new MessageB();
var router = new MessageRouter();
router.Route(a);
router.Route(b);
}
public void Reset()
{
_c.Dispose();
MessageA.Reset();
MessageB.Reset();
MessageC.Reset();
_aCount = 0;
_bCount = 0;
_cCount = 0;
}
public MessageB Update(MessageB addComment)
{
var message = messages.SingleOrDefault(m => m.Id == addComment.Id);
if (message != null)
{
addComment.comment = message.comment + addComment.comment;
}
return(message);
}
public async Task Consume(ConsumeContext <MessageA> context)
{
this.logger.LogInformation($"The correlationId from scopedCache is: [{this.scopedCache.ConversationId}].");
var msg = new MessageB();
await context.Publish(msg, msg.GetType(), context =>
{
context.ConversationId = this.scopedCache.ConversationId;
}).ConfigureAwait(false);
}
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 async Task PublishCorrelatingMessage()
{
this.logger.LogInformation($"The correlationId from scopedCache is: [{this.scopedCache.ConversationId}].");
var msg = new MessageB();
await this.publishEndpoint.Publish(msg, msg.GetType(), context =>
{
context.ConversationId = this.scopedCache.ConversationId;
}).ConfigureAwait(false);
}
public override Task <ResponseB> Func2(MessageB msg)
{
Log("func2 called");
ResponseB response = new ResponseB
{
MemesInt = msg.MemesInt,
MemesFloat = msg.MemesFloat
};
return(Task.FromResult(response));
}
public async Task CallFunc2()
{
foreach (IClient client in _clients)
{
MessageB msg = new MessageB
{
MemesInt = 420,
MemesFloat = 4.3f
};
ResponseB recv = await client.Func2(msg);
Console.WriteLine($"Server received {recv} from {client.Id}");
}
}
public void Go()
{
var a = new MessageA();
var b = new MessageB();
var c = new MessageC();
var router = new MessageRouter();
router.RegisterHandler(new HandlerA());
router.RegisterHandler(new HandlerB());
router.Route(a);
router.Route(b);
router.Route(c);
}
public static void Main(string[] args)
{
Console.WriteLine("Start !!");
AMessage messageA = new MessageA();
AMessage messageB = new MessageB();
AMessage messageC = new MessageC();
MessageB messageBBis = null;
ExecutMessageMethod(messageA);
ExecutMessageMethod(messageB);
ExecutMessageMethod(messageC);
ExecutMessageMethod(messageBBis);
Console.ReadLine();
}
public IActionResult OnGet(int?messageId)
{
if (messageId.HasValue)
{
message = listsData.GetById(messageId.Value);
}
else
{
message = new MessageB();
}
if (message == null)
{
return(RedirectToPage("./NotFound"));
}
return(Page());
}
public void DeeplyNestedMessagesShouldApplyEventsProperly()
{
var g = new MessageG();
g.H.Add(1);
AssertEventsStable(g);
var f = new MessageF();
f.G = g;
f.G.H.Add(2);
AssertEventsStable(f);
var e = new MessageE();
e.F = f;
e.F.G.H.Add(3);
AssertEventsStable(e);
var d = new MessageD();
d.E = e;
d.E.F.G.H.Add(4);
AssertEventsStable(d);
var c = new MessageC();
c.D["foo"] = d;
c.D["foo"].E.F.G.H.Add(5);
AssertEventsStable(c);
var b = new MessageB();
b.C["bar"] = c;
b.C["bar"].D["foo"].E.F.G.H.Add(6);
AssertEventsStable(b);
var a = new MessageA();
a.B = b;
a.B.C["bar"].D["foo"].E.F.G.H.Add(7);
AssertEventsStable(a);
}
public void Handle <T>(T args)
{
var msgB = args as MessageB;
if (msgB == null)
{
msgB = new MessageB {
TextB = "~B~"
}
}
;
_builder.Append(msgB.TextB);
var msgC = new MessageC {
TextC = "~C~"
};
_innerHandler.Handle(msgC);
}
}
public void Should_use_converter_for_deserialization()
{
var obj = new MessageB {Value = "Joe"};
MessageB result = SerializeAndReturn(obj);
result.Value.ShouldBe("Monster");
}
void IConsume <MessageB> .Consume(MessageB message, CancellationToken cancellationToken)
{
}
public Task ConsumeAsync(MessageB message, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public void Receive(MessageB message)
{
Bs++;
}
private void MessageBNotification(MessageB message)
{
Console.WriteLine($"A Received a notification from: {message.LogMessage}");
}
public MessageB Add(MessageB newMessageB)
{
db.Add(newMessageB);
return(newMessageB);
}
public MessageB Add(MessageB newMessageB)
{
messages.Add(newMessageB);
newMessageB.Id = messages.Max(m => m.Id) + 1;
return(newMessageB);
}
public void Consume(MessageB message)
{
}
public void Handle(MessageB message)
{
_receivedB.TrySetResult(message);
}
public void Consume(MessageB message)
{
_receivedB.TrySetResult(message);
}
public Task Consume(MessageB message)
{
throw new NotImplementedException();
}
