Merge pull request #111 from Azure/dev

0.0.2-preview release

Author: jtaubensee

README.md

@@ -6,15 +6,16 @@
 
 **Please be aware that this library is currently in active development, and is not intended for production**
 
-[![Build status](https://ci.appveyor.com/api/projects/status/anpaipqto58ka5lk/branch/master?svg=true)](https://ci.appveyor.com/project/jtaubensee/azure-service-bus-dotnet/branch/master)
+|Build/Package|Status|
+|------|-------------|
+|master|[![Build status](https://ci.appveyor.com/api/projects/status/anpaipqto58ka5lk/branch/master?svg=true)](https://ci.appveyor.com/project/jtaubensee/azure-service-bus-dotnet/branch/master)|
+|dev|[![Build status](https://ci.appveyor.com/api/projects/status/anpaipqto58ka5lk/branch/master?svg=true)](https://ci.appveyor.com/project/jtaubensee/azure-service-bus-dotnet/branch/dev)|
 
 This is the next generation Service Bus .NET client library that focuses on queues & topics. If you are looking for Event Hubs and Relay clients, follow the below links:
 * [Event Hubs](https://github.com/azure/azure-event-hubs-dotnet)
 * [Relay](https://github.com/azure/azure-relay-dotnet)
- 
-For information on the current set of implemented features and features to come, see our [Road map](#road-map).
 
-Azure Service Bus Messaging is an asynchronous messaging cloud platform that enables you to send messages between decoupled systems. Microsoft offers this feature as a service, which means that you do not need to host any of your own hardware in order to use it.
+Azure Service Bus is an asynchronous messaging cloud platform that enables you to send messages between decoupled systems. Microsoft offers this feature as a service, which means that you do not need to host any of your own hardware in order to use it.
 
 Refer to the [online documentation](https://azure.microsoft.com/services/service-bus/) to learn more about Service Bus.
 
@@ -55,38 +56,3 @@ The standard way to manage Azure resources is by using [Azure Resource Manager](
 * GitHub repo - [https://github.com/Azure/azure-sdk-for-net/tree/AutoRest/src/ResourceManagement/ServiceBus](https://github.com/Azure/azure-sdk-for-net/tree/AutoRest/src/ResourceManagement/ServiceBus)
 * NuGet package - [https://www.nuget.org/packages/Microsoft.Azure.Management.ServiceBus/](https://www.nuget.org/packages/Microsoft.Azure.Management.ServiceBus/)
 * Sample - [https://github.com/Azure-Samples/service-bus-dotnet-management](https://github.com/Azure-Samples/service-bus-dotnet-management)
-
-## Road map
-
-- [x] Sprint 1: **Complete**
-
-  All runtime operations for queues (not topics / subscriptions)
-    * Send
-    * Receive/Peeklock (without receive by sequence number)
-    * Abandon
-    * Deadletter
-    * Defer
-  
-- [x] Sprint 2: **Complete**
-  * RenewLock (Request/Response)
-  * Batch operation  - Explicit batching only
-  * Runtime operation only
-  * Linux testing setup/investigation
-
-- [x] Sprint 3: **Complete**
-  * Add topic/subscription support
-  * Session support
-    * Accept session
-    * Session Receive/ReceiveBatch
-	
-- [x] Sprint 4: **Complete**
-  * Retry policy
-  * Receive by sequence number
-
-- [ ] Sprint 5: Early 2017
-  * Add major error conditions (ex. preventing all operations that are not supported, for Ex Transaction scenarios, etc)
-  * Request/Response features:
-      * Add/Remove Rule
-      * Browse messages and sessions
-  * Scheduled messages specific API (Scheduling of messages can be done today through the queue/topic client, but this item is to add specific API's for scheduled messages)
-  * OnMessage/OnSession handlers

samples/ReceiveSample/Program.cs

@@ -4,61 +4,54 @@
 namespace ReceiveSample
 {
     using System;
+    using System.Text;
     using System.Threading.Tasks;
     using Microsoft.Azure.ServiceBus;
 
     public class Program
     {
-        private static QueueClient queueClient;
+        private static IQueueClient queueClient;
         private const string ServiceBusConnectionString = "{Service Bus connection string}";
         private const string QueueName = "{Queue path/name}";
 
         public static void Main(string[] args)
         {
-            MainAsync(args).GetAwaiter().GetResult();
+            MainAsync().GetAwaiter().GetResult();
         }
 
-        private static async Task MainAsync(string[] args)
+        private static async Task MainAsync()
         {
-            // Creates a ServiceBusConnectionStringBuilder object from the connection string, and sets the EntityPath.
-            var connectionStringBuilder = new ServiceBusConnectionStringBuilder(ServiceBusConnectionString)
-            {
-                EntityPath = QueueName
-            };
-
-            // Initializes the static QueueClient variable that will be used in the ReceiveMessages method.
-            queueClient = QueueClient.CreateFromConnectionString(connectionStringBuilder.ToString());
+            queueClient = new QueueClient(ServiceBusConnectionString, QueueName, ReceiveMode.PeekLock);
+            ReceiveMessages();
 
-            await ReceiveMessages();
+            Console.WriteLine("Press any key to stop receiving messages.");
+            Console.ReadKey();
 
             // Close the client after the ReceiveMessages method has exited.
             await queueClient.CloseAsync();
         }
 
         // Receives messages from the queue in a loop
-        private static async Task ReceiveMessages()
+        private static void ReceiveMessages()
         {
-            Console.WriteLine("Press ctrl-c to exit receive loop.");
-            while (true)
+            try
             {
-                try
-                {
-                    // Receive the next message from the queue
-                    var message = await queueClient.ReceiveAsync();
-                    
-                    // Write the message body to the console
-                    Console.WriteLine($"Received message: {message.GetBody<string>()}");
-
-                    // Complete the message so that it is not received again
-                    await message.CompleteAsync();
-                }
-                catch (Exception exception)
-                {
-                    Console.WriteLine($"{DateTime.Now} > Exception: {exception.Message}");
-                }
-
-                // Delay by 10 milliseconds so that the console can keep up
-                await Task.Delay(10);
+                // Register a OnMessage callback
+                queueClient.RegisterMessageHandler(
+                    async (message, token) =>
+                    {
+                        // Process the message
+                        Console.WriteLine($"Received message: SequenceNumber:{message.SystemProperties.SequenceNumber} Body:{Encoding.UTF8.GetString(message.Body)}");
+
+                        // Complete the message so that it is not received again.
+                        // This can be done only if the queueClient is opened in ReceiveMode.PeekLock mode.
+                        await queueClient.CompleteAsync(message.SystemProperties.LockToken);
+                    },
+                    new RegisterHandlerOptions() {MaxConcurrentCalls = 1, AutoComplete = false});
+            }
+            catch (Exception exception)
+            {
+                Console.WriteLine($"{DateTime.Now} > Exception: {exception.Message}");
             }
         }
     }

samples/ReceiveSample/readme.md

@@ -59,31 +59,24 @@ In this tutorial, we will write a console application to receive messages from a
 1. Create a new method called `ReceiveMessages` with the following code:
 
     ```csharp
-    // Receives messages from the queue in a loop
-    private static async Task ReceiveMessages()
+    try
     {
-        Console.WriteLine("Press ctrl-c to exit receive loop.");
-        while (true)
-        {
-            try
+        // Register a OnMessage callback
+        queueClient.RegisterMessageHandler(
+            async (message, token) =>
             {
-                // Receive the next message from the queue
-                var message = await queueClient.ReceiveAsync();
-                
-                // Write the message body to the console
-                Console.WriteLine($"Received message: {message.GetBody<string>()}");
-
-                // Complete the messgage so that it is not received again
-                await message.CompleteAsync();
-            }
-            catch (Exception exception)
-            {
-                Console.WriteLine($"{DateTime.Now} > Exception: {exception.Message}");
-            }
-
-            // Delay by 10 milliseconds so that the console can keep up
-            await Task.Delay(10);
-        }
+                // Process the message
+                Console.WriteLine($"Received message: SequenceNumber:{message.SequenceNumber} Body:{message.GetBody<string>()}");
+
+                // Complete the message so that it is not received again.
+                // This can be done only if the queueClient is opened in ReceiveMode.PeekLock mode.
+                await queueClient.CompleteAsync(message.LockToken);
+            },
+            new RegisterHandlerOptions() {MaxConcurrentCalls = 1, AutoComplete = false});
+    }
+    catch (Exception exception)
+    {
+        Console.WriteLine($"{DateTime.Now} > Exception: {exception.Message}");
     }
     ```
 
@@ -92,16 +85,11 @@ In this tutorial, we will write a console application to receive messages from a
     ```csharp
     private static async Task MainAsync(string[] args)
     {
-        // Creates a ServiceBusConnectionStringBuilder object from the connection string, and sets the EntityPath.
-        var connectionStringBuilder = new ServiceBusConnectionStringBuilder(ServiceBusConnectionString)
-        {
-            EntityPath = QueueName
-        };
-
-        // Initializes the static QueueClient variable that will be used in the ReceiveMessages method.
-        queueClient = QueueClient.CreateFromConnectionString(connectionStringBuilder.ToString());
+        queueClient = new QueueClient(ServiceBusConnectionString, QueueName, ReceiveMode.PeekLock);
+        ReceiveMessages();
 
-        await ReceiveMessages();
+        Console.WriteLine("Press any key to stop receiving messages.");
+        Console.ReadKey();
 
         // Close the client after the ReceiveMessages method has exited.
         await queueClient.CloseAsync();

samples/SendSample/Program.cs

@@ -4,12 +4,13 @@
 namespace SendSample
 {
     using System;
+    using System.Text;
     using System.Threading.Tasks;
     using Microsoft.Azure.ServiceBus;
 
     public class Program
     {
-        private static QueueClient queueClient;
+        private static IQueueClient queueClient;
         private const string ServiceBusConnectionString = "{Service Bus connection string}";
         private const string QueueName = "{Queue path/name}";
 
@@ -20,14 +21,7 @@ public static void Main(string[] args)
 
         private static async Task MainAsync(string[] args)
         {
-            // Creates a ServiceBusConnectionStringBuilder object from the connection string, and sets the EntityPath.
-            var connectionStringBuilder = new ServiceBusConnectionStringBuilder(ServiceBusConnectionString)
-            {
-                EntityPath = QueueName
-            };
-
-            // Initializes the static QueueClient variable that will be used in the ReceiveMessages method.
-            queueClient = QueueClient.CreateFromConnectionString(connectionStringBuilder.ToString());
+            queueClient = new QueueClient(ServiceBusConnectionString, QueueName, ReceiveMode.PeekLock);
 
             await SendMessagesToQueue(10);
 
@@ -46,10 +40,10 @@ private static async Task SendMessagesToQueue(int numMessagesToSend)
                 try
                 {
                     // Create a new brokered message to send to the queue
-                    var message = new BrokeredMessage($"Message {i}");
+                    var message = new Message(Encoding.UTF8.GetBytes($"Message {i}"));
 
                     // Write the body of the message to the console
-                    Console.WriteLine($"Sending message: {message.GetBody<string>()}");
+                    Console.WriteLine($"Sending message: {Encoding.UTF8.GetString(message.Body)}");
 
                     // Send the message to the queue
                     await queueClient.SendAsync(message);

samples/SendSample/readme.md

@@ -66,7 +66,7 @@ In this tutorial, we will write a console application to send messages to a Serv
             try
             {
                 // Create a new brokered message to send to the queue
-                var message = new BrokeredMessage($"Message {i}");
+                var message = new Message($"Message {i}");
 
                 // Write the body of the message to the console
                 Console.WriteLine($"Sending message: {message.GetBody<string>()}");
@@ -92,15 +92,7 @@ In this tutorial, we will write a console application to send messages to a Serv
     ```csharp
     private static async Task MainAsync(string[] args)
     {
-        // Creates a ServiceBusConnectionStringBuilder object from the connection string, and sets the EntityPath.
-        var connectionStringBuilder = new ServiceBusConnectionStringBuilder(ServiceBusConnectionString)
-        {
-            EntityPath = QueueName
-        };
-
-        // Initializes the static QueueClient variable that will be used in the ReceiveMessages method.
-        queueClient = QueueClient.CreateFromConnectionString(connectionStringBuilder.ToString());
-
+        queueClient = new QueueClient(ServiceBusConnectionString, QueueName, ReceiveMode.PeekLock);
         await SendMessagesToQueue(10);
 
         // Close the client after the ReceiveMessages method has exited.