protected async void cmdSend1_Click(object sender, EventArgs e) { byte[] dataArr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; BrokeredMessage msg = new BrokeredMessage(dataArr); msg.Properties.Add("suma", 1); msg.Properties.Add("srednia", 1); msg.ReplyToSessionId = Guid.NewGuid().ToString("N"); await m_tc.SendAsync(msg); MessageSession session = m_qc.AcceptMessageSession(msg.ReplyToSessionId, TimeSpan.FromSeconds(60)); List <BrokeredMessage> lst = new List <BrokeredMessage>(); while (lst.Count < 3) { msg = await session.ReceiveAsync(); //Potem można: session.ReceiveAsync(msg.SequenceNumber + 1) if (msg != null) { lst.Add(msg); await msg.CompleteAsync(); } } lblInfo.Text = ""; foreach (var item in lst) { lblInfo.Text += item.GetBody <string>(); } }
static void SendMessages(QueueClient requestClient, QueueClient responseClient) { // Send request messages to queue: Console.WriteLine("Sending request messages to queue {0}", requestClient.Path); Console.WriteLine("Receiving response messages on queue {0}", responseClient.Path); MessageSession receiver = responseClient.AcceptMessageSession(ReplyToSessionId); for (int i = 0; i < SampleManager.NumMessages; ++i) { // send request message BrokeredMessage message = CreateRequestMessage(i); requestClient.Send(message); SampleManager.OutputMessageInfo("REQUEST: ", message); // receive response message BrokeredMessage receivedMessage = receiver.Receive(TimeSpan.FromSeconds(ResponseMessageTimeout)); if (receivedMessage != null) { SampleManager.OutputMessageInfo("RESPONSE: ", message); receivedMessage.Complete(); } else { Console.WriteLine("ERROR: Response timed out."); } } receiver.Close(); Console.WriteLine(); }
public static void ReceiveQ() { Console.WriteLine("In Receive method()."); TokenProvider credentials = TokenProvider.CreateSharedSecretTokenProvider(QReceiver.IssuerName, QReceiver.IssuerKey); Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", QReceiver.ServiceNamespace, string.Empty); MessagingFactory factory = null; factory = MessagingFactory.Create(serviceUri, credentials); QueueClient sessionQueueClient = factory.CreateQueueClient(QReceiver.QueueName); //Create sessionQueueClient and subscribe to SessionIDs that have a value of "Mike" MessageSession sessionReceiver = sessionQueueClient.AcceptMessageSession("92610", TimeSpan.FromSeconds(60)); BrokeredMessage receivedMessage; while ((receivedMessage = sessionReceiver.Receive(TimeSpan.FromSeconds(60))) != null) { Console.WriteLine("Received Messages."); var data = receivedMessage.GetBody <FireEvent>(new DataContractSerializer(typeof(FireEvent))); //Console.WriteLine(String.Format("Customer Name: {0}", data.CustomerName)); Console.WriteLine("SessionID: {0}", receivedMessage.SessionId); //remove message from Topic receivedMessage.Complete(); } Console.WriteLine("All received on this session...press enter to exit"); Console.Read(); }
/// <summary> /// Get all messages with a specific session /// </summary> /// <param name="client">QueueClient</param> private void GetAllMessagesWithSession(QueueClient client) { foreach (MessageSession sessions in client.GetMessageSessions()) { try { MessageSession ses = client.AcceptMessageSession(sessions.SessionId); BrokeredMessage item = ses.Receive(properties.ReceiveTimeout); while (true) { if (item == null) { break; } if (SubmitMessage(item) == false) { ses.Abort(); break; } //allow setting timeout item = ses.Receive(properties.ReceiveTimeout); } } catch (Exception) { break; } } }
/// <summary> /// Get all messages that has a session /// </summary> /// <param name="client">QueueClient</param> private void GetSessionMessages(QueueClient client) { try { MessageSession ses = client.AcceptMessageSession(properties.Session); BrokeredMessage item = ses.Receive(properties.ReceiveTimeout); while (true) { if (item == null) { break; } if (SubmitMessage(item) == false) { ses.Abort(); break; } //allow setting timeout item = ses.Receive(properties.ReceiveTimeout); } } catch (Exception) { //probably lock } }
private static void ReceiveMessages() { Console.WriteLine("\nReceiving message from Queue..."); BrokeredMessage message = null; var sessions = queueClient.GetMessageSessions(); foreach (var browser in sessions) { Console.WriteLine(string.Format("Session discovered: Id = {0}", browser.SessionId)); var session = queueClient.AcceptMessageSession(browser.SessionId); while (true) { try { message = session.Receive(TimeSpan.FromSeconds(5)); if (message != null) { Console.WriteLine(string.Format("Message received: Id = {0}, Body = {1}", message.MessageId, message.GetBody <string>())); if (session.SessionId == SessionId2) { // if this is the second session then let's send to the dead letter for fun message.DeadLetter(); } else { // Further custom message processing could go here... message.Complete(); } } else { //no more messages in the queue break; } } catch (MessagingException e) { if (!e.IsTransient) { Console.WriteLine(e.Message); throw; } else { HandleTransientErrors(e); } } } } queueClient.Close(); }
public FileMessage ReceiveLargeMessage(CancellationTokenSource cancel) { var largeMessageStream = new MemoryStream(); MessageSession session = _queueClient.AcceptMessageSession(); _logger.LogMessage($"Message session Id: {session.SessionId}"); _logger.LogMessage("Receiving sub messages"); bool isFirst = true; string fileName = ""; while (true) { BrokeredMessage subMessage = session.Receive(TimeSpan.FromSeconds(5)); if (subMessage != null) { if (cancel.IsCancellationRequested) { break; } try { if (isFirst) { //receive filename fileName = subMessage.GetBody <string>(); isFirst = false; } else { //receive filestream Stream subMessageStream = subMessage.GetBody <Stream>(); subMessageStream.CopyTo(largeMessageStream); } subMessage.Complete(); } catch (Exception ex) { _logger.LogException(ex); } } else { _logger.LogMessage("Done!"); break; } } BrokeredMessage largeMessage = new BrokeredMessage(largeMessageStream, true); return(new FileMessage(fileName, largeMessage)); }
public async Task <ActionResult> Add(int a = 5, int b = 12) { int result = 0; Param p = new Param { A = a, B = b }; BrokeredMessage msg = new BrokeredMessage(p); msg.Properties.Add("operation", 1); msg.ReplyToSessionId = Guid.NewGuid().ToString("N"); await m_tc.SendAsync(msg); MessageSession session = m_qc.AcceptMessageSession(msg.ReplyToSessionId, TimeSpan.FromSeconds(60)); msg = await session.ReceiveAsync(); if (msg != null) { result = msg.GetBody <int>(); } return(View(result)); }
static void Main(string[] args) { ParseArgs(args); // Create MessageReceiver for queue which does not require session Console.Title = "MessageReceiver"; QueueClient sessionlessQueueClient = CreateQueueClient(SampleManager.SessionlessQueueName); Console.WriteLine("Ready to receive messages from {0}...", sessionlessQueueClient.Path); lastReceive = DateTime.Now; ReceiveMessages(sessionlessQueueClient); // Create SessionReceiver for queue requiring session Console.Title = "SessionReceiver"; QueueClient sessionQueueClient = CreateQueueClient(SampleManager.SessionQueueName); Console.Clear(); Console.WriteLine("Ready to receive messages from {0}...", sessionQueueClient.Path); bool allSessionsAccepted = false; while (!allSessionsAccepted) { try { // Please note that AcceptMessageSession(sessionId) can be used if sessionId is already known. This sample // demonstrates where it is unknown. Console.WriteLine("Checking for session..."); MessageSession sessionReceiver = sessionQueueClient.AcceptMessageSession(TimeSpan.FromSeconds(acceptSessionReceiverTimeout)); ReceiveSessionMessages(sessionReceiver); Console.WriteLine("All received on this session"); } catch (TimeoutException) { Console.WriteLine("Got TimeoutException, no more sessions available"); allSessionsAccepted = true; } } Console.WriteLine("\nReceiver complete."); Console.ReadLine(); }
public void ProcessSessionQueue(QueueClient sourceClient, QueueClient destinationClient) { _activityLogger.Log($"[{sourceClient.Path}] - Processing queue requiring a session", 0, 1); var totalMessagesForwarded = 0; var messageSessions = sourceClient.GetMessageSessions(); if (messageSessions.Any()) { var sessionIds = new List <string>(); // obtain session IDs and then close these sessions, as they are browse-only foreach (var messageSession in messageSessions) { sessionIds.Add(messageSession.SessionId); messageSession.Close(); } foreach (var sessionId in sessionIds) { _activityLogger.Log($"[{sourceClient.Path}] - Processing queue session ID: {sessionId} "); var messagesRemaining = true; while (messagesRemaining) { var messageSession = sourceClient.AcceptMessageSession(sessionId, _serverWaitTime); var messages = messageSession.ReceiveBatch(_messagesToHandle, _serverWaitTime); var messageCount = messages.Count(); if (messageCount > 0) { _activityLogger.Log($"Batch of {messageCount} message(s) received for processing", 1); var messagesForwarded = 0; foreach (var message in messages) { // log message _messageLogger?.Log($"Queue: [{sourceClient.Path}]\n{message.GetSingleLineContent()}\n"); destinationClient.Send(message.Clone()); messagesForwarded++; totalMessagesForwarded++; message.Complete(); } _activityLogger.Log($"Processing complete: {messagesForwarded} message(s) forwarded", 1); } else { messagesRemaining = false; _activityLogger.Log($"No {(totalMessagesForwarded > 0 ? "more " : "")}messages to process in this session", 1); } messageSession.Close(); } } } else { _activityLogger.Log("No sessions exist - no messages to forward", 1); } _activityLogger.Log($"[{sourceClient.Path}] - Completed processing queue - {totalMessagesForwarded} message(s) forwarded"); }
static void Main(string[] args) { Console.WriteLine("Checkout Console"); // Create the NamespaceManager NamespaceManager namespaceMgr = //new NamespaceManager(serviceBusUri, credentials); NamespaceManager.CreateFromConnectionString(AccountDetails.ConnectionString); // Create the MessagingFactory MessagingFactory factory = //MessagingFactory.Create(serviceBusUri, credentials); MessagingFactory.CreateFromConnectionString(AccountDetails.ConnectionString); // Delete the queue if it exists. if (namespaceMgr.QueueExists(AccountDetails.QueueName)) { namespaceMgr.DeleteQueue(AccountDetails.QueueName); } // Create a description for the queue. QueueDescription rfidCheckoutQueueDescription = new QueueDescription(AccountDetails.QueueName) { // Comment in to require duplicate detection RequiresDuplicateDetection = true, DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(10), // Comment in to require sessions RequiresSession = true }; // Create a queue based on the queue description. namespaceMgr.CreateQueue(rfidCheckoutQueueDescription); // Use the MessagingFactory to create a queue client for the // specified queue. QueueClient queueClient = factory.CreateQueueClient(AccountDetails.QueueName); Console.WriteLine("Receiving tag read messages..."); while (true) { int receivedCount = 0; double billTotal = 0.0; // Comment in to use a session receiver Console.ForegroundColor = ConsoleColor.Cyan; var messageSession = queueClient.AcceptMessageSession(); Console.WriteLine("Accepted session: " + messageSession.SessionId); Console.ForegroundColor = ConsoleColor.Yellow; while (true) { // Receive a tag read message. // Swap comments to use a session receiver //var receivedTagRead = queueClient.Receive(TimeSpan.FromSeconds(5)); var receivedTagRead = messageSession.Receive(TimeSpan.FromSeconds(5)); if (receivedTagRead != null) { // Process the message. RfidTag tag = receivedTagRead.GetBody <RfidTag>(); Console.WriteLine("Bill for {0}", tag.Product); receivedCount++; billTotal += tag.Price; // Mark the message as complete receivedTagRead.Complete(); } else { break; } } if (receivedCount > 0) { // Bill the customer. Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine ("Bill customer ${0} for {1} items.", billTotal, receivedCount); Console.WriteLine(); Console.ResetColor(); } } }
static void Main(string[] args) { string connStr = ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"]; Console.WriteLine("Client"); try { var payload = new Messages.Message(); payload.MyMessage = "Hello world"; var messageId = Guid.NewGuid().ToString(); Console.WriteLine($"My Mesasge ID is {messageId}"); BrokeredMessage bm = new BrokeredMessage(payload); bm.ReplyToSessionId = messageId; NamespaceManager ns = NamespaceManager.CreateFromConnectionString(connStr); if (!ns.QueueExists("MyQueueRequest")) { QueueDescription queue = new QueueDescription("MyQueueRequest"); queue.EnablePartitioning = false; queue.RequiresSession = false; ns.CreateQueue(queue); } if (!ns.QueueExists("MyQueueResponse")) { QueueDescription queue = new QueueDescription("MyQueueResponse"); queue.EnablePartitioning = false; queue.RequiresSession = true; ns.CreateQueue(queue); } // Sending to a queue QueueClient qClient = QueueClient.CreateFromConnectionString(connStr, "MyQueueRequest"); qClient.Send(bm); Console.WriteLine("Sent Message!"); // Listen for a session based message. QueueClient qClientResponse = QueueClient.CreateFromConnectionString(connStr, "MyQueueResponse"); var messageSession = qClientResponse.AcceptMessageSession(messageId); messageSession.OnMessage(message => { Console.WriteLine("I've Received a Message."); Console.WriteLine($"Message ID: {message.MessageId} - {message.SessionId}"); var receivedPayload = message.GetBody <Messages.Message>(); Console.WriteLine($"Message from service - {receivedPayload.MyMessage}"); }, new OnMessageOptions()); } catch (Exception e) { Console.WriteLine(e); } Console.ReadLine(); }