public static void Listen()
{
if (queueClient == null)
{
queueClient = new QueueClient(ServiceBusConnectionString, QueueName);
}
if (messageHandlerOptions == null)
{
messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
AutoComplete = true, MaxConcurrentCalls = 1
};
}
queueClient.RegisterMessageHandler(Handler, messageHandlerOptions);
}
static void RegisterOnMessageHandlerAndReceiveMessages()
{
// Configure the MessageHandler Options in terms of exception handling, number of concurrent messages to deliver etc.
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
// Maximum number of Concurrent calls to the callback `ProcessMessagesAsync`, set to 1 for simplicity.
// Set it according to how many messages the application wants to process in parallel.
MaxConcurrentCalls = 1,
// Indicates whether MessagePump should automatically complete the messages after returning from User Callback.
// False below indicates the Complete will be handled by the User Callback as in `ProcessMessagesAsync` below.
AutoComplete = false
};
// Register the function that will process messages
queueClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
}
public async Task RegisterMessageHandler_CanSetMessageHandlerOptions()
{
// Arrange
Task MessageHandler(IMessage message, CancellationToken cancellationToken)
{
throw new Exception("There should be no messages to process.");
}
var options = new MessageHandlerOptions
{
MaxConcurrentCalls = 1,
ExceptionReceivedHandler = (_) => Task.CompletedTask
};
// Act
await _sut.RegisterMessageHandler(MessageHandler, options);
}
public Task StartAsync(CancellationToken cancellationToken)
{
this.queueClient = new QueueClient(configuration.GetValue <string>("ServiceBusConnectionString"), configuration.GetValue <string>("ServiceBusQueueName"));
var messageHandlerOptions = new MessageHandlerOptions(e => {
ProcessError(e.Exception);
return(Task.CompletedTask);
})
{
MaxConcurrentCalls = 3,
AutoComplete = false
};
this.queueClient.RegisterMessageHandler(ProcessMessageAsync, messageHandlerOptions);
return(Task.CompletedTask);
}
static async Task Main(string[] args)
{
BombProcess();
_queueClient = new QueueClient(connectionString, queueName);
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = false
};
_queueClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
Console.ReadLine();
await _queueClient.CloseAsync();
}
private void RegisterOnMessageHandlerAndReceiveMessages()
{
try
{
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = false
};
queueClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
}
catch (Exception ex)
{
//LoggingHelper.LogTraceException(ex, MethodBase.GetCurrentMethod().DeclaringType.FullName, MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// Starts listening for messages on the configured Service Bus Queue.
/// </summary>
protected override void ListenForMessages()
{
var options = new MessageHandlerOptions(ExceptionReceivedHandler)
{
AutoComplete = false
};
if (AutoRenewTimeout.HasValue)
{
options.MaxAutoRenewDuration = AutoRenewTimeout.Value;
}
if (MaxConcurrentCalls.HasValue)
{
options.MaxConcurrentCalls = MaxConcurrentCalls.Value;
}
ServiceBusClient.RegisterMessageHandler(ReceiveMessageAsync, options);
}
public async Task ReceiveMessageFromTopic <T>(Func <T, MessageProcessResponse> onProcess)
{
MessageHandlerOptions options = new MessageHandlerOptions(e =>
{
Trace.TraceError(e.Exception.Message);
return(Task.CompletedTask);
})
{
AutoComplete = false,
MaxAutoRenewDuration = TimeSpan.FromMinutes(1)
};
await Task.Run(() => _subscriptionClient.RegisterMessageHandler(
async(message, token) =>
{
try
{
// Get message
string data = Encoding.UTF8.GetString(message.Body);
T item = JsonConvert.DeserializeObject <T>(data);
// Process message
MessageProcessResponse result = onProcess(item);
switch (result)
{
case MessageProcessResponse.Complete:
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
break;
case MessageProcessResponse.Abandon:
await _subscriptionClient.AbandonAsync(message.SystemProperties.LockToken);
break;
case MessageProcessResponse.Dead:
await _subscriptionClient.DeadLetterAsync(message.SystemProperties.LockToken);
break;
}
}
catch (Exception ex)
{
await _subscriptionClient.DeadLetterAsync(message.SystemProperties.LockToken);
Trace.TraceError(ex.Message);
}
}, options));
}
static void RegisterOnMessageHandlerAndReceiveMessages()
{
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 10,
AutoComplete = false
};
if (UseQueue)
{
queueClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
}
else
{
subscriptionClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
}
}
public static SubscriptionClient ReadFromTopicSubscription(IEndpoint subscriptionEndpoint, ITestMessageHandler handler)
{
var builder = new ServiceBusConnectionStringBuilder(subscriptionEndpoint.Settings.ConnectionString);
var subName = builder.EntityPath.Substring(
builder.EntityPath.IndexOf("/subscriptions/") + 15);
var subscriptionClient = new SubscriptionClient(builder, subName, ReceiveMode.ReceiveAndDelete, RetryPolicy.NoRetry);
var messageHandlerOptions = new MessageHandlerOptions(handler.HandleException)
{
MaxConcurrentCalls = 1,
AutoComplete = true
};
subscriptionClient.RegisterMessageHandler(handler.HandleMessage, messageHandlerOptions);
return(subscriptionClient);
}
private void ProcessQueueMessages()
{
if (_queueClient != null)
{
return;
}
_queueClient = new QueueClient(_connectionStringForReading, _queueName, ReceiveMode.ReceiveAndDelete);
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 2,
AutoComplete = true
};
_queueClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
}
public async Task Upon_product_changed_message_received_and_an_error_occur_should_log()
{
//Arrange
MessageHandlerOptions messageHandlerOptions = null;
_subscriptionClient.When(q => q.RegisterMessageHandler(Arg.Any <Func <Message, CancellationToken, Task> >(), Arg.Any <MessageHandlerOptions>()))
.Do(c => messageHandlerOptions = c.Arg <MessageHandlerOptions>());
var productChangedSubscriber = new ProductChangedSubscriber(_mapper, _mergeService, _subscriptionClient, _unitOfWork);
//Act
await messageHandlerOptions.ExceptionReceivedHandler(_fixture.Create <ExceptionReceivedEventArgs>());
//Assert
await _unitOfWork.LogRepository.Received().SaveAsync(Arg.Any <string>());
}
public void Receive(
Func <T, MessageProcessResponse> onProcess,
Action <Exception> onError,
Action onWait)
{
var options = new MessageHandlerOptions(e => { onError(e.Exception); return(Task.CompletedTask); })
{
AutoComplete = false,
MaxAutoRenewDuration = TimeSpan.FromMinutes(1)
};
_client.RegisterMessageHandler(
async(message, token) =>
{
try
{
// Get message
var data = Encoding.UTF8.GetString(message.Body);
T item = JsonConvert.DeserializeObject <T>(data);
// Process message
var result = onProcess(item);
if (result == MessageProcessResponse.Complete)
{
await _client.CompleteAsync(message.SystemProperties.LockToken);
}
else if (result == MessageProcessResponse.Abandon)
{
await _client.AbandonAsync(message.SystemProperties.LockToken);
}
else if (result == MessageProcessResponse.Dead)
{
await _client.DeadLetterAsync(message.SystemProperties.LockToken);
}
// Wait for next message
onWait();
}
catch (Exception ex)
{
await _client.DeadLetterAsync(message.SystemProperties.LockToken);
onError(ex);
}
}, options);
}
public void Receive(Func <T, MessageProcessResponse> onProcess, Action <Exception> onError, Action onWait)
{
var options = new MessageHandlerOptions(e =>
{
onError(e.Exception);
return(Task.CompletedTask);
})
{
AutoComplete = false
};
_queueClient.RegisterMessageHandler(
async(message, token) =>
{
try
{
var data = Encoding.UTF8.GetString(message.Body);
T item = JsonConvert.DeserializeObject <T>(data);
var result = onProcess(item);
switch (result)
{
case MessageProcessResponse.Complete:
await _queueClient.CompleteAsync(message.SystemProperties.LockToken);
break;
case MessageProcessResponse.Abandon:
await _queueClient.AbandonAsync(message.SystemProperties.LockToken);
break;
case MessageProcessResponse.Dead:
await _queueClient.DeadLetterAsync(message.SystemProperties.LockToken);
break;
}
//waiting for next message
onWait();
}
catch (Exception e)
{
await _queueClient.DeadLetterAsync(message.SystemProperties.LockToken);
onError(e);
}
}, options);
}
static void Main(string[] args)
{
var serviceBusClient =
new SubscriptionClient("<ServiceBusConnectionString>", "pagamentofeito", "PagamentoFeitoServicoB");
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = false
};
serviceBusClient.RegisterMessageHandler(ProcessMessageAsync, messageHandlerOptions);
while (true)
{
}
}
private static void RegisterOnMessageHandlerAndReceiveMessages()
{
// Configure the message handler options in terms of exception handling, number of concurrent messages to deliver, etc.
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
// Maximum number of concurrent calls to the callback MrocessMesagesAsync(), set to 1 for simplicity
// Set it according to how many messages the application wants to process in parallel
MaxConcurrentCalls = 1,
// Indicates whether the message pumo should automatically complete the messages after returning from use callback.
// False below indicates the complete operation is handled by the user call back as in ProcessMessagesAsync().
AutoComplete = false
};
// Register the function that processes messages.
subscriptionClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
}
static void Main(string[] args)
{
queueClient = new QueueClient(ServiceBusConnectionString, QueueName);
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = false
};
queueClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
Console.WriteLine($"Consumer is ready");
Console.ReadKey();
queueClient.CloseAsync().Wait();
}
public async Task <IBusSubscriber> SubscribeEvent <TEvent>(string @namespace = null, string queueName = null,
Func <TEvent, Exception, IRejectedEvent> onError = null) where TEvent : IEvent
{
var client = new ManagementClient(azureConnection);
if (!await client.SubscriptionExistsAsync(@namespace, queueName, CancellationToken.None))
{
await client.CreateSubscriptionAsync(@namespace, queueName, CancellationToken.None);
}
SubscriptionClient subscriptionClient = new SubscriptionClient(azureConnection, @namespace, queueName, ReceiveMode.ReceiveAndDelete, RetryPolicy.Default);
var options = new MessageHandlerOptions(e =>
{
return(Task.CompletedTask);
})
{
AutoComplete = false,
MaxAutoRenewDuration = TimeSpan.FromMinutes(1)
};
subscriptionClient.RegisterMessageHandler(
async(message, token) =>
{
TEvent @event = default(TEvent);
try
{
// Get message
var data = Encoding.UTF8.GetString(message.Body);
var propertydata = message.UserProperties["context"] as string;
@event = JsonConvert.DeserializeObject <TEvent>(data);
CorrelationContext correlationContext = JsonConvert.DeserializeObject <CorrelationContext>(propertydata);
var eventHandler = provider.GetService <IEventHandler <TEvent> >();
//return await TryHandleAsync(@event, correlationContext,
await BaseTryHandleAsync(@event, correlationContext,
() => eventHandler.HandleAsync(@event, correlationContext), onError);
}
catch (Exception ex)
{
//await client.DeadLetterAsync(message.SystemProperties.LockToken);
onError(@event, ex);
}
}, options);
return(this);
}
//Part 2: Received Message from the Service Bus - cal get data function
public async Task <IActionResult> ProcessMsg()
{
//queueClient = new QueueClient(ServiceBusConnectionString, QueueName, ReceiveMode.PeekLock);
items = new List <string>();
await Task.Factory.StartNew(() =>
{
queueClient = new QueueClient(ServiceBusConnectionString, QueueName, ReceiveMode.PeekLock);
var options = new MessageHandlerOptions(ExceptionMethod)
{
MaxConcurrentCalls = 1,
AutoComplete = false
};
queueClient.RegisterMessageHandler(ExecuteMessageProcessing, options);
});
return(RedirectToAction("ProcessMsgResult"));
}
public void Receive()
{
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = false
};
_queueClient.RegisterMessageHandler(async(Message rawMessage, CancellationToken token) =>
{
var message = rawMessage.Body.FromJsonBytes <Message <T> >();
DataReceived?.Invoke(this, message);
await _queueClient.CompleteAsync(rawMessage.SystemProperties.LockToken);
}, messageHandlerOptions);
}
public List <TType> Peek(int count = 1)
{
var result = new List <TType>();
var options = new MessageHandlerOptions(ExceptionReceivedHandler)
{
AutoComplete = false, MaxConcurrentCalls = 1
};
_queueClient.RegisterMessageHandler(ProcessMessagesAsync, options);
while (MessageProcessedCount < count)
{
Thread.Sleep(1000);
}
return(result);
}
/// <summary>
/// Method to Receive a message from a subscription
/// </summary>
/// <param name="userName">the username of the user to get messages</param>
public static void ReceiveMessageSubscription(string TopicName, string userName)
{
lop = userName;
if (string.IsNullOrWhiteSpace(userName))
{
throw new ArgumentNullException(nameof(userName));
}
//to avoid any typo, lower the string
string userNameLow = userName.ToLowerInvariant();
if (ConnectionString != null)
{
Task.Run(() =>
{
try
{
Client = new SubscriptionClient(ConnectionString, TopicName, userName);
// Configure message handler
// Values are default but set for illustration
var messageHandlerOptions =
new MessageHandlerOptions(ExceptionReceivedHandler)
{
AutoComplete = false,
// ExceptionReceivedHandler = set in constructor
MaxAutoRenewDuration = new TimeSpan(0, 5, 0), // 5 minutes
MaxConcurrentCalls = 1,
};
// Register the function that processes messages.
// Once set new message will be received
Client.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.Message + ", " + ex.StackTrace);
}
Console.ReadKey();
Client.CloseAsync();
});
}
}
public void RegisterOnMessageHandlerAndReceiveMessages()
{
_logger.LogInformation("Creating subscription client");
_subscriptionClient = new SubscriptionClient(
_endpointConfiguration.ConnectionString,
_endpointConfiguration.Topic,
_endpointConfiguration.Subscription);
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = false
};
_logger.LogInformation("Registering message handler");
_subscriptionClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
}
public void Listen()
{
queueClient = new QueueClient(ServiceBusConnectionString, QueueName, ReceiveMode.ReceiveAndDelete);
//subClient = new SubscriptionClient(ServiceBusConnectionString, QueueName, "Whiteboard");
var m = new MessageHandlerOptions(ExceptionHandler)
{
AutoComplete = true
};
queueClient.RegisterMessageHandler(MessageHandler, m);
//subClient.RegisterMessageHandler(MessageHandler, m);
Console.WriteLine("Queue Listening process started! Press any key to exit the program.");
Console.ReadKey();
}
public void Receive(Action <Message <TKey, TValue> > action)
{
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = false,
};
_subscriptionClient.RegisterMessageHandler((Message message, CancellationToken token) =>
{
action(new Message <TKey, TValue>
{
Key = JsonConvert.DeserializeObject <TKey>(message.MessageId),
Value = JsonConvert.DeserializeObject <TValue>(Encoding.UTF8.GetString(message.Body))
});
return(_subscriptionClient.CompleteAsync(message.SystemProperties.LockToken));
}, messageHandlerOptions);
}
public static void RegisterOnMessageHandlerAndReceiveMessages()
{
// Configure the message handler options in terms of exception handling, number of concurrent messages to deliver, etc.
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
// Maximum number of concurrent calls to the callback ProcessMessagesAsync(), set to 1 for simplicity.
// Set it according to how many messages the application wants to process in parallel.
MaxConcurrentCalls = 10,
// Indicates whether MessagePump should automatically complete the messages after returning from User Callback.
// False below indicates the Complete will be handled by the User Callback as in `ProcessMessagesAsync` below.
AutoComplete = false,
MaxAutoRenewDuration = TimeSpan.FromMinutes(2),
};
// Register the function that processes messages.
s_subscriptionClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
}
static async Task Main()
{
Console.WriteLine("Starting SpeedTestLogger");
_config = new LoggerConfiguration();
var options = new MessageHandlerOptions(HandleException)
{
MaxConcurrentCalls = 1,
AutoComplete = true
};
_subscriptionClient = new SubscriptionClient(_config.ServiceBus.ConnectionString, _config.ServiceBus.TopicName, _config.ServiceBus.SubscriptionName);
_subscriptionClient.RegisterMessageHandler(HandleSpeedTestMessage, options);
Console.ReadKey();
await _subscriptionClient.CloseAsync();
}
static void Main(string[] args)
{
var configuration = BuildConfiguration();
subscribtionClient = new SubscriptionClient(configuration["serviceBusConnection"],
configuration["topicName"], args[0], receiveMode: ReceiveMode.PeekLock);
Console.WriteLine($"Connection to topic : {configuration["topicName"]} and subscription : {args[0]}");
var options = new MessageHandlerOptions(ExceptionHandler)
{
AutoComplete = false
};
subscribtionClient.RegisterMessageHandler(ReceiveMessage, options);
WaitForEnd();
}
public Task StartAsync(CancellationToken cancellationToken)
{
subscriptionClient = new SubscriptionClient(configuration.GetValue <string>("ServiceBusConnectionString"), configuration.GetValue <string>("OrderPaymentRequestMessageTopic"), configuration.GetValue <string>("subscriptionName"));
var messageHandlerOptions = new MessageHandlerOptions(e =>
{
ProcessError(e.Exception);
return(Task.CompletedTask);
})
{
MaxConcurrentCalls = 3,
AutoComplete = false
};
subscriptionClient.RegisterMessageHandler(ProcessMessageAsync, messageHandlerOptions);
return(Task.CompletedTask);
}
public void RegisterMessageHandler(Func <T, string, CancellationToken, Task> handler)
{
var handlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = false
};
_client.RegisterMessageHandler(async(message, ct) =>
{
var item = await TryDeserialize(message);
if (item == null)
{
return;
}
await handler(item, message.SystemProperties.LockToken, ct);
}, handlerOptions);
}
