(0) exportieren Drucken
Alle erweitern

Schritt 4: Empfangen von Nachrichten von der Warteschlange

Dies ist der vierte Schritt im Lernprogramm zu den Service Bus-Messagingfunktionen. In diesem Schritt rufen Sie die Liste der Nachrichten aus der Warteschlange ab, die Sie im vorherigen Schritt erstellt haben.

So erstellen Sie einen Empfänger und empfangen Nachrichten aus der Warteschlange

  1. Iterieren Sie in der Methode Queue() durch die Warteschlange, und empfangen Sie die Nachricht dann mithilfe der Methode Receive, indem Sie jede Nachricht in der Konsole ausgeben. Fügen Sie den folgenden Code direkt unter dem Code hinzu, den Sie im vorherigen Schritt hinzugefügt haben:

    Console.WriteLine("Now receiving messages from Queue.");
    BrokeredMessage message;
    while ((message = myQueueClient.Receive(new TimeSpan(hours: 0, minutes: 1, seconds: 5))) != null)
        {
            Console.WriteLine(string.Format("Message received: {0}, {1}, {2}", message.SequenceNumber, message.Label, message.MessageId));
            message.Complete();
    
            Console.WriteLine("Processing message (sleeping...)");
            Thread.Sleep(1000);
        }
    

So beenden Sie die Methode "Queue()" und bereinigen die Ressourcen

  1. Fügen Sie direkt unterhalb des zuvor hinzugefügten Codes den folgenden Code hinzu, um die Nachrichtenfactory und die Warteschlangenressourcen zu bereinigen:

    factory.Close();
    myQueueClient.Close();
    namespaceClient.DeleteQueue("IssueTrackingQueue");
    

So rufen Sie die Methode "Queue()" auf

  1. Der letzte Schritt besteht im Hinzufügen einer Anweisung, die die Methode Queue() aus der Methode Main() aufruft. Fügen Sie die folgende hervorgehobene Codezeile am Ende der Methode Main() hinzu:

    public static void Main(string[] args)
    {
        // Collect user input
        CollectUserInput();
    
        // Populate test data
        issues = ParseCSVFile();
        MessageList = GenerateMessages(issues);
    
        // Add this call
        Queue();
    }
    

Beispiel

Der folgende Code enthält die vollständige QueueSample-Anwendung.

using System;
using System.Threading;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.ServiceBus;
using Microsoft.ServiceBus.Messaging;
using Microsoft.ServiceBus.Description;
using System.Data;
using System.IO;

namespace Microsoft.ServiceBus.Samples
{
    class Program
    {

        private static DataTable issues;
        private static List<BrokeredMessage> MessageList;

        private static string ServiceNamespace;
        private static string IssuerName;
        private static string IssuerKey;


public static void Main(string[] args)
{

    // Populate test data
    issues = ParseCSVFile();

       MessageList = GenerateMessages(issues);

       CollectUserInput();

       Queue();
       

}
        static DataTable ParseCSVFile()
        {
            DataTable tableIssues = new DataTable("Issues");
            string path = @"..\..\data.csv";
            try
            {
                using (StreamReader readFile = new StreamReader(path))
                {
                    string line;
                    string[] row;

                    // create the columns
                    line = readFile.ReadLine();
                    foreach (string columnTitle in line.Split(','))
                    {
                        tableIssues.Columns.Add(columnTitle);
                    }

                    while ((line = readFile.ReadLine()) != null)
                    {
                        row = line.Split(',');
                        tableIssues.Rows.Add(row);
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Error:" + e.ToString());
            }

            return tableIssues;
        }

        static List<BrokeredMessage> GenerateMessages(DataTable issues)
        {
            // Instantiate the brokered list object
            List<BrokeredMessage> result = new List<BrokeredMessage>();

            // Iterate through the table and create a brokered message for each row
            foreach (DataRow item in issues.Rows)
            {
                BrokeredMessage message = new BrokeredMessage();
                foreach (DataColumn property in issues.Columns)
                {
                    message.Properties.Add(property.ColumnName, item[property]);
                }
                result.Add(message);
            }
            return result;
        }

        static void CollectUserInput()
        {
            // User service namespace
            Console.Write("Please enter the service namespace to use: ");
            ServiceNamespace = Console.ReadLine();

            // Issuer name
            Console.Write("Please enter the issuer name to use: ");
            IssuerName = Console.ReadLine();

            // Issuer key
            Console.Write("Please enter the issuer key to use: ");
            IssuerKey = Console.ReadLine();
        }


            static void Queue()
{
            // Create management credentials
    TokenProvider credentials =
                TokenProvider.CreateSharedSecretTokenProvider(IssuerName, IssuerKey);

                NamespaceManager namespaceClient = new NamespaceManager(ServiceBusEnvironment.CreateServiceUri("sb", ServiceNamespace, string.Empty), credentials);

                //QueueDescription myQueue;
                //myQueue = namespaceClient.CreateQueue("IssueTrackingQueue");
                namespaceClient.CreateQueue("IssueTrackingQueue");

                MessagingFactory factory = MessagingFactory.Create(ServiceBusEnvironment.CreateServiceUri("sb", ServiceNamespace, string.Empty), credentials);

                QueueClient myQueueClient = factory.CreateQueueClient("IssueTrackingQueue");

                // Create a sender
                //MessageSender myMessageSender = myQueueClient.CreateSender();

                // Send messages
                Console.WriteLine("Now sending messages to the Queue.");
                for (int count = 0; count < 6; count++)
                {
                    var issue = MessageList[count];
                    issue.Label = issue.Properties["IssueTitle"].ToString();
                    myQueueClient.Send(issue);
                    Console.WriteLine(string.Format("Message sent: {0}, {1}", issue.Label, issue.MessageId));
                }

                Console.WriteLine("Now receiving messages from Queue.");
                BrokeredMessage message;
                while ((message = myQueueClient.Receive(new TimeSpan(hours: 0, minutes: 1, seconds: 5))) != null)
                {
                    Console.WriteLine(string.Format("Message received: {0}, {1}, {2}", message.SequenceNumber, message.Label, message.MessageId));
                    message.Complete();

                    Console.WriteLine("Processing message (sleeping...)");
                    Thread.Sleep(1000);
                }

                factory.Close();
                myQueueClient.Close();
                namespaceClient.DeleteQueue("IssueTrackingQueue");
}
        
    }

}

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft