private static void Main(string[] args)
{
var queueAddress = ".\\private$\\sixeyed.messagequeue.unsubscribe-legacy";
var properties = new Dictionary <string, object>();
properties.Add("MulticastAddress", "234.1.1.2:8001");
using (var queue = MessageQueueFactory.CreateInbound(queueAddress, MessagePattern.PublishSubscribe, properties))
{
Console.WriteLine("Listening on: {0}", queueAddress);
Console.WriteLine("Listening on: {0}", queueAddress);
queue.Listen(x =>
{
if (x.BodyType == typeof(UserUnsubscribed))
{
var unsubscribedEvent = x.BodyAs <UserUnsubscribed>();
Console.WriteLine("Starting UnsubscribeLegacyWorkflow for: {0}, at: {1}",
unsubscribedEvent.EmailAddress, DateTime.Now.TimeOfDay);
var workflow = new UnsubscribeLegacyWorkflow(unsubscribedEvent.EmailAddress);
workflow.Run();
Console.WriteLine("Completed UnsubscribeLegacyWorkflow for: {0}, at: {1}",
unsubscribedEvent.EmailAddress, DateTime.Now.TimeOfDay);
}
});
}
}
public void Fire_And_Forget_Async()
{
using (var sender = MessageQueueFactory.CreateOutbound("ffasync", MessagePattern.FireAndForget))
using (var receiver = MessageQueueFactory.CreateInbound("ffasync", MessagePattern.FireAndForget))
{
var outgoingMessage = new Message
{
Body = new[] { "hello world" }
};
sender.Send(outgoingMessage);
var cancellationTokenSource = new CancellationTokenSource(2000);
var cancellationToken = cancellationTokenSource.Token;
string result = string.Empty;
var task = receiver.Listen(incomingMessage =>
{
result = incomingMessage.BodyAs <string[]>()[0];
},
cancellationToken);
task.Wait();
cancellationTokenSource.Cancel();
result.Should().Be("hello world");
Trace.WriteLine(result);
}
}
public void Reqest_Resonse()
{
using (var sender = MessageQueueFactory.CreateOutbound("ff", MessagePattern.RequestResponse))
using (var receiver = MessageQueueFactory.CreateInbound("ff", MessagePattern.RequestResponse))
{
var responseQueue = sender.GetResponseQueue();
var outgoingMessage = new Message
{
Body = new[] { "how are you?" },
ResponseAddressName = responseQueue.MessageAddress.Address
};
sender.Send(outgoingMessage);
var responseMessage = new Message
{
Body = new[] { "I am fine, thank you." }
};
receiver.Receive(incomingMessage =>
{
var replyQueue = receiver.GetReplyQueue(incomingMessage);
replyQueue.Send(responseMessage);
});
string result = string.Empty;
responseQueue.Receive(incomingMessage => result = incomingMessage.BodyAs <string[]>()[0]);
result.Should().Be("I am fine, thank you.");
}
}
public void Pusblish_Subscribe()
{
using (var publisher = MessageQueueFactory.CreateOutbound("topic", MessagePattern.PublishSubscribe))
using (var subscriber1 = MessageQueueFactory.CreateInbound("subscription1", MessagePattern.PublishSubscribe))
using (var subscriber2 = MessageQueueFactory.CreateInbound("subscription2", MessagePattern.PublishSubscribe))
using (var subscriber3 = MessageQueueFactory.CreateInbound("subscription3", MessagePattern.PublishSubscribe))
{
var outgoingMessage = new Message
{
Body = new[] { "hello world" }
};
publisher.Send(outgoingMessage);
string result1, result2, result3;
result1 = result2 = result3 = string.Empty;
subscriber1.Receive(incomingMessage => result1 = incomingMessage.BodyAs <string[]>()[0]);
subscriber2.Receive(incomingMessage => result2 = incomingMessage.BodyAs <string[]>()[0]);
subscriber3.Receive(incomingMessage => result3 = incomingMessage.BodyAs <string[]>()[0]);
result1.Should().Be("hello world");
result2.Should().Be("hello world");
result3.Should().Be("hello world");
}
}
public override IMessageQueue GetResponseQueue()
{
var createRequest = new CreateQueueRequest();
createRequest.QueueName = Guid.NewGuid().ToString().Substring(0, 6);
var createResponse = _sqsClient.CreateQueue(createRequest);
var responseQueue = MessageQueueFactory.CreateInbound(createResponse.QueueUrl, MessagePattern.RequestResponse, true);
return(responseQueue);
}
public virtual IMessageQueue GetResponseQueue()
{
if (!(Pattern == MessagePattern.RequestResponse && Direction == Direction.Outbound))
{
throw new InvalidOperationException("Cannot get a response queue except for outbound request-response");
}
var address = CreateResponseQueueAddress();
return(MessageQueueFactory.CreateInbound(address, MessagePattern.RequestResponse, true, this));
}
public override IMessageQueue GetResponseQueue()
{
if (!(Pattern == MessagePattern.RequestResponse && Direction == Direction.Outbound))
throw new InvalidOperationException("Cannot get a response queue except for outbound request-response");
var namespaceManager = NamespaceManager.CreateFromConnectionString(_connectionString);
var responseAddress = Guid.NewGuid().ToString().Substring(0, 6);
namespaceManager.CreateQueue(responseAddress);
var responseQueue = MessageQueueFactory.CreateInbound(responseAddress, MessagePattern.RequestResponse, true);
return responseQueue;
}
public override IMessageQueue GetResponseQueue()
{
if (!(Pattern == MessagePattern.RequestResponse && Direction == Direction.Outbound))
{
throw new InvalidOperationException("Cannot get a response queue except for outbound request-response");
}
var responseAddress = string.Format(".\\private$\\{0}", Guid.NewGuid().ToString().Substring(0, 6));
msmq.MessageQueue.Create(responseAddress);
var responseQueue = MessageQueueFactory.CreateInbound(responseAddress, MessagePattern.RequestResponse, true);
return(responseQueue);
}
private static void StartListening(string name, MessagePattern pattern)
{
var queue = MessageQueueFactory.CreateInbound(name, pattern);
Console.WriteLine("Listening on: {0}", queue.Address);
queue.Listen(x =>
{
if (x.BodyType == typeof(UnsubscribeCommand))
{
Unsubscribe(x.BodyAs <UnsubscribeCommand>());
}
else if (x.BodyType == typeof(DoesUserExistRequest))
{
CheckUserExists(x.BodyAs <DoesUserExistRequest>(), x, queue);
}
});
}
private void StartListening(string name, MessagePattern pattern)
{
var queue = MessageQueueFactory.CreateInbound(name, pattern);
Log.WriteLine("Listening with queue type: {0}, on address: {1}", queue.GetType().Name, queue.Address);
queue.Listen(x =>
{
if (x.BodyType == typeof(UnsubscribeCommand))
{
Unsubscribe(x.BodyAs <UnsubscribeCommand>());
}
else if (x.BodyType == typeof(DoesUserExistRequest))
{
CheckUserExists(x.BodyAs <DoesUserExistRequest>(), x, queue);
}
}, _cancellationTokenSource.Token);
}
public void Fire_And_Forget()
{
using (var sender = MessageQueueFactory.CreateOutbound("ff", MessagePattern.FireAndForget))
using (var receiver = MessageQueueFactory.CreateInbound("ff", MessagePattern.FireAndForget))
{
var outgoingMessage = new Message
{
Body = new[] { "hello world" }
};
sender.Send(outgoingMessage);
string result = string.Empty;
receiver.Receive(incomingMessage => result = incomingMessage.BodyAs <string[]>()[0]);
result.Should().Be("hello world");
}
}
private void StartListening <TWorkflow>(string name, MessagePattern pattern)
where TWorkflow : IUserWorkflow, new()
{
var queue = MessageQueueFactory.CreateInbound(name, pattern);
Log.WriteLine("Listening with queue type: {0}, on address: {1}", queue.GetType().Name, queue.Address);
queue.Listen(x =>
{
if (x.BodyType == typeof(UserUnsubscribed))
{
var unsubscribedEvent = x.BodyAs <UserUnsubscribed>();
Log.WriteLine("Starting {0} for: {1}, at: {2}", typeof(TWorkflow).Name,
unsubscribedEvent.EmailAddress, DateTime.Now.TimeOfDay);
var workflow = new TWorkflow
{
EmailAddress = unsubscribedEvent.EmailAddress
};
workflow.Run();
Log.WriteLine("Completed {0} for: {1}, at: {2}", typeof(TWorkflow).Name,
unsubscribedEvent.EmailAddress, DateTime.Now.TimeOfDay);
}
}, _cancellationTokenSource.Token);
}
private static void StartListening <TWorkflow>(string name, MessagePattern pattern)
where TWorkflow : IUserWorkflow, new()
{
var queue = MessageQueueFactory.CreateInbound(name, pattern);
Console.WriteLine("Listening on: {0}", queue.Address);
queue.Listen(x =>
{
if (x.BodyType == typeof(UserUnsubscribed))
{
var unsubscribedEvent = x.BodyAs <UserUnsubscribed>();
Console.WriteLine("Starting {0} for: {1}, at: {2}", typeof(TWorkflow).Name,
unsubscribedEvent.EmailAddress, DateTime.Now.TimeOfDay);
var workflow = new TWorkflow
{
EmailAddress = unsubscribedEvent.EmailAddress
};
workflow.Run();
Console.WriteLine("Completed {0} for: {1}, at: {2}", typeof(TWorkflow).Name,
unsubscribedEvent.EmailAddress, DateTime.Now.TimeOfDay);
}
});
}
