Prepare for release

eng/Packages.Data.props

@@ -14,7 +14,7 @@
 		<PackageReference Update="Azure.AI.TextAnalytics" Version="5.0.0" />
     <PackageReference Update="Azure.Data.AppConfiguration" Version="1.0.0" />
     <PackageReference Update="Azure.Core" Version="1.6.0" />
-    <PackageReference Update="Azure.Core.Amqp" Version="1.0.0-beta.1" />
+    <PackageReference Update="Azure.Core.Amqp" Version="1.0.0" />
     <PackageReference Update="Azure.Core.Experimental" Version="0.1.0-preview.7" />
     <PackageReference Update="Azure.Identity" Version="1.2.1" />
     <PackageReference Update="Azure.Search.Documents" Version="11.1.1" />

sdk/servicebus/Azure.Messaging.ServiceBus/CHANGELOG.md

@@ -1,7 +1,11 @@
 # Release History
 
-## 7.0.0-preview.10 (Unreleased)
-
+## 7.0.0 (2020-11-23)
+### Breaking Changes
+- Renamed GetRawMessage method to GetRawAmqpMessage.
+- Removed LinkCloseMode.
+- Rename ReceiveMode type to ServiceBusReceiveMode.
+- Remove ServiceBusFailureReason of Unauthorized in favor of using UnauthorizedAccessException.
 
 ## 7.0.0-preview.9 (2020-11-04)
 

sdk/servicebus/Azure.Messaging.ServiceBus/README.md

@@ -37,7 +37,7 @@ To quickly create the needed Service Bus resources in Azure and to receive a con
 Install the Azure Service Bus client library for .NET with [NuGet](https://www.nuget.org/):
 
 ```PowerShell
-dotnet add package Azure.Messaging.ServiceBus --version 7.0.0-preview.9
+dotnet add package Azure.Messaging.ServiceBus --version 7.0.0
 ```
 
 ### Authenticate the client
@@ -112,8 +112,8 @@ await using var client = new ServiceBusClient(connectionString);
 // create the sender
 ServiceBusSender sender = client.CreateSender(queueName);
 
-// create a message that we can send
-ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!"));
+// create a message that we can send. UTF-8 encoding is used when providing a string.
+ServiceBusMessage message = new ServiceBusMessage("Hello world!");
 
 // send the message
 await sender.SendMessageAsync(message);
@@ -131,27 +131,61 @@ Console.WriteLine(body);
 
 ### Send and receive a batch of messages
 
-There are two ways of sending several messages at once. The first way uses the `SendMessagesAsync` overload that accepts an IEnumerable of `ServiceBusMessage`. With this method, we will attempt to fit all of the supplied messages in a single message batch that we will send to the service. If the messages are too large to fit in a single batch, the operation will throw an exception.
+There are two ways of sending several messages at once. The first way of doing this uses safe-batching. With safe-batching, you can create a `ServiceBusMessageBatch` object, which will allow you to attempt to add messages one at a time to the batch using the `TryAdd` method. If the message cannot fit in the batch, `TryAdd` will return false.
+
+```C# Snippet:ServiceBusSendAndReceiveSafeBatch
+// add the messages that we plan to send to a local queue
+Queue<ServiceBusMessage> messages = new Queue<ServiceBusMessage>();
+messages.Enqueue(new ServiceBusMessage("First message"));
+messages.Enqueue(new ServiceBusMessage("Second message"));
+messages.Enqueue(new ServiceBusMessage("Third message"));
+
+// create a message batch that we can send
+// total number of messages to be sent to the Service Bus queue
+int messageCount = messages.Count;
+
+// while all messages are not sent to the Service Bus queue
+while (messages.Count > 0)
+{
+    // start a new batch
+    using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
+
+    // add the first message to the batch
+    if (messageBatch.TryAddMessage(messages.Peek()))
+    {
+        // dequeue the message from the .NET queue once the message is added to the batch
+        messages.Dequeue();
+    }
+    else
+    {
+        // if the first message can't fit, then it is too large for the batch
+        throw new Exception($"Message {messageCount - messages.Count} is too large and cannot be sent.");
+    }
+
+    // add as many messages as possible to the current batch
+    while (messages.Count > 0 && messageBatch.TryAddMessage(messages.Peek()))
+    {
+        // dequeue the message from the .NET queue as it has been added to the batch
+        messages.Dequeue();
+    }
+
+    // now, send the batch
+    await sender.SendMessagesAsync(messageBatch);
+
+    // if there are any remaining messages in the .NET queue, the while loop repeats
+}
+```
+
+The second way uses the `SendMessagesAsync` overload that accepts an IEnumerable of `ServiceBusMessage`. With this method, we will attempt to fit all of the supplied messages in a single message batch that we will send to the service. If the messages are too large to fit in a single batch, the operation will throw an exception.
 
 ```C# Snippet:ServiceBusSendAndReceiveBatch
 IList<ServiceBusMessage> messages = new List<ServiceBusMessage>();
-messages.Add(new ServiceBusMessage(Encoding.UTF8.GetBytes("First")));
-messages.Add(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second")));
+messages.Add(new ServiceBusMessage("First"));
+messages.Add(new ServiceBusMessage("Second"));
 // send the messages
 await sender.SendMessagesAsync(messages);
 ```
 
-The second way of doing this is using safe-batching. With safe-batching, you can create a `ServiceBusMessageBatch` object, which will allow you to attempt to add messages one at a time to the batch using the `TryAdd` method. If the message cannot fit in the batch, `TryAdd` will return false.
-
-```C# Snippet:ServiceBusSendAndReceiveSafeBatch
-ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
-messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("First")));
-messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second")));
-
-// send the message batch
-await sender.SendMessagesAsync(messageBatch);
-```
-
 ### Complete a message
 
 In order to remove a message from a queue or subscription, we can call the `CompleteAsync` method.

sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample01_HelloWorld.md

@@ -15,8 +15,8 @@ await using var client = new ServiceBusClient(connectionString);
 // create the sender
 ServiceBusSender sender = client.CreateSender(queueName);
 
-// create a message that we can send
-ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!"));
+// create a message that we can send. UTF-8 encoding is used when providing a string.
+ServiceBusMessage message = new ServiceBusMessage("Hello world!");
 
 // send the message
 await sender.SendMessageAsync(message);
@@ -38,21 +38,55 @@ There are two ways of sending several messages at once. The first way uses the `
 
 ```C# Snippet:ServiceBusSendAndReceiveBatch
 IList<ServiceBusMessage> messages = new List<ServiceBusMessage>();
-messages.Add(new ServiceBusMessage(Encoding.UTF8.GetBytes("First")));
-messages.Add(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second")));
+messages.Add(new ServiceBusMessage("First"));
+messages.Add(new ServiceBusMessage("Second"));
 // send the messages
 await sender.SendMessagesAsync(messages);
 ```
 
 The second way of doing this is using safe-batching. With safe-batching, you can create a `ServiceBusMessageBatch` object, which will allow you to attempt to messages one at a time to the batch using TryAdd. If the message cannot fit in the batch, TryAdd will return false.
 
 ```C# Snippet:ServiceBusSendAndReceiveSafeBatch
-ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
-messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("First")));
-messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second")));
-
-// send the message batch
-await sender.SendMessagesAsync(messageBatch);
+// add the messages that we plan to send to a local queue
+Queue<ServiceBusMessage> messages = new Queue<ServiceBusMessage>();
+messages.Enqueue(new ServiceBusMessage("First message"));
+messages.Enqueue(new ServiceBusMessage("Second message"));
+messages.Enqueue(new ServiceBusMessage("Third message"));
+
+// create a message batch that we can send
+// total number of messages to be sent to the Service Bus queue
+int messageCount = messages.Count;
+
+// while all messages are not sent to the Service Bus queue
+while (messages.Count > 0)
+{
+    // start a new batch
+    using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
+
+    // add the first message to the batch
+    if (messageBatch.TryAddMessage(messages.Peek()))
+    {
+        // dequeue the message from the .NET queue once the message is added to the batch
+        messages.Dequeue();
+    }
+    else
+    {
+        // if the first message can't fit, then it is too large for the batch
+        throw new Exception($"Message {messageCount - messages.Count} is too large and cannot be sent.");
+    }
+
+    // add as many messages as possible to the current batch
+    while (messages.Count > 0 && messageBatch.TryAddMessage(messages.Peek()))
+    {
+        // dequeue the message from the .NET queue as it has been added to the batch
+        messages.Dequeue();
+    }
+
+    // now, send the batch
+    await sender.SendMessagesAsync(messageBatch);
+
+    // if there are any remaining messages in the .NET queue, the while loop repeats
+}
 ```
 
 ## Peeking a message

sdk/servicebus/Azure.Messaging.ServiceBus/src/Azure.Messaging.ServiceBus.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <Description>Azure Service Bus is a fully managed enterprise integration message broker. Service Bus can decouple applications and services. Service Bus offers a reliable and secure platform for asynchronous transfer of data and state. This client library allows for both sending and receiving messages using Azure Service Bus. For more information about Service Bus, see https://docs.microsoft.com/en-us/azure/service-bus-messaging/service-bus-messaging-overview</Description>
-    <Version>7.0.0-preview.10</Version>
+    <Version>7.0.0</Version>
     <PackageTags>Azure;Service Bus;ServiceBus;.NET;AMQP;$(PackageCommonTags)</PackageTags>
     <TargetFrameworks>$(RequiredTargetFrameworks)</TargetFrameworks>
   </PropertyGroup>
@@ -12,6 +12,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Azure.Core.Amqp" />
     <PackageReference Include="Microsoft.Azure.Amqp" />
     <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" />
     <!--This can be removed once this dependency is added to Core in the next release.-->

sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample01_HelloWorld.cs

@@ -28,8 +28,8 @@ public async Task SendAndReceiveMessage()
                 // create the sender
                 ServiceBusSender sender = client.CreateSender(queueName);
 
-                // create a message that we can send
-                ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!"));
+                // create a message that we can send. UTF-8 encoding is used when providing a string.
+                ServiceBusMessage message = new ServiceBusMessage("Hello world!");
 
                 // send the message
                 await sender.SendMessageAsync(message);
@@ -61,7 +61,7 @@ public async Task SendAndPeekMessage()
                 ServiceBusSender sender = client.CreateSender(queueName);
 
                 // create a message that we can send
-                ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!"));
+                ServiceBusMessage message = new ServiceBusMessage("Hello world!");
 
                 // send the message
                 await sender.SendMessageAsync(message);
@@ -97,8 +97,8 @@ public async Task SendAndReceiveMessageBatch()
                 ServiceBusSender sender = client.CreateSender(queueName);
                 #region Snippet:ServiceBusSendAndReceiveBatch
                 IList<ServiceBusMessage> messages = new List<ServiceBusMessage>();
-                messages.Add(new ServiceBusMessage(Encoding.UTF8.GetBytes("First")));
-                messages.Add(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second")));
+                messages.Add(new ServiceBusMessage("First"));
+                messages.Add(new ServiceBusMessage("Second"));
                 // send the messages
                 await sender.SendMessagesAsync(messages);
                 #endregion
@@ -143,14 +143,47 @@ public async Task SendAndReceiveMessageSafeBatch()
                 // create the sender
                 ServiceBusSender sender = client.CreateSender(queueName);
 
-                // create a message batch that we can send
                 #region Snippet:ServiceBusSendAndReceiveSafeBatch
-                ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
-                messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("First")));
-                messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second")));
+                // add the messages that we plan to send to a local queue
+                Queue<ServiceBusMessage> messages = new Queue<ServiceBusMessage>();
+                messages.Enqueue(new ServiceBusMessage("First message"));
+                messages.Enqueue(new ServiceBusMessage("Second message"));
+                messages.Enqueue(new ServiceBusMessage("Third message"));
 
-                // send the message batch
-                await sender.SendMessagesAsync(messageBatch);
+                // create a message batch that we can send
+                // total number of messages to be sent to the Service Bus queue
+                int messageCount = messages.Count;
+
+                // while all messages are not sent to the Service Bus queue
+                while (messages.Count > 0)
+                {
+                    // start a new batch
+                    using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
+
+                    // add the first message to the batch
+                    if (messageBatch.TryAddMessage(messages.Peek()))
+                    {
+                        // dequeue the message from the .NET queue once the message is added to the batch
+                        messages.Dequeue();
+                    }
+                    else
+                    {
+                        // if the first message can't fit, then it is too large for the batch
+                        throw new Exception($"Message {messageCount - messages.Count} is too large and cannot be sent.");
+                    }
+
+                    // add as many messages as possible to the current batch
+                    while (messages.Count > 0 && messageBatch.TryAddMessage(messages.Peek()))
+                    {
+                        // dequeue the message from the .NET queue as it has been added to the batch
+                        messages.Dequeue();
+                    }
+
+                    // now, send the batch
+                    await sender.SendMessagesAsync(messageBatch);
+
+                    // if there are any remaining messages in the .NET queue, the while loop repeats
+                }
                 #endregion
 
                 // create a receiver that we can use to receive the messages
@@ -164,12 +197,6 @@ public async Task SendAndReceiveMessageSafeBatch()
                     // get the message body as a string using an implicit cast
                     string body = receivedMessage.Body.ToString();
                 }
-                var sentMessagesEnum = messageBatch.AsEnumerable<ServiceBusMessage>().GetEnumerator();
-                foreach (ServiceBusReceivedMessage receivedMessage in receivedMessages)
-                {
-                    sentMessagesEnum.MoveNext();
-                    Assert.AreEqual(sentMessagesEnum.Current.Body.ToString(), receivedMessage.Body.ToString());
-                }
             }
         }