< Summary

Class:Azure.Messaging.ServiceBus.Amqp.AmqpMessageBatch
Assembly:Azure.Messaging.ServiceBus
File(s):C:\Git\azure-sdk-for-net\sdk\servicebus\Azure.Messaging.ServiceBus\src\Amqp\AmqpMessageBatch.cs
Covered lines:38
Uncovered lines:1
Coverable lines:39
Total lines:175
Line coverage:97.4% (38 of 39)
Covered branches:7
Total branches:8
Branch coverage:87.5% (7 of 8)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
get_MaxSizeInBytes()-100%100%
get_SizeInBytes()-100%100%
get_Count()-100%100%
get_Options()-0%100%
get_BatchMessages()-100%100%
.ctor(...)-100%100%
TryAddMessage(...)-100%83.33%
Clear()-100%100%
AsEnumerable()-100%100%
Dispose()-100%100%

File(s)

C:\Git\azure-sdk-for-net\sdk\servicebus\Azure.Messaging.ServiceBus\src\Amqp\AmqpMessageBatch.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4using System;
 5using System.Collections.Generic;
 6using System.Globalization;
 7using System.Linq;
 8using Azure.Core;
 9using Azure.Messaging.ServiceBus.Core;
 10using Microsoft.Azure.Amqp;
 11
 12namespace Azure.Messaging.ServiceBus.Amqp
 13{
 14    /// <summary>
 15    ///   A set of messages with known size constraints, based on messages to be sent
 16    ///   using an AMQP-based transport.
 17    /// </summary>
 18    ///
 19    internal class AmqpMessageBatch : TransportMessageBatch
 20    {
 21        /// <summary>The amount of bytes to reserve as overhead for a small message.</summary>
 22        private const byte OverheadBytesSmallMessage = 5;
 23
 24        /// <summary>The amount of bytes to reserve as overhead for a large message.</summary>
 25        private const byte OverheadBytesLargeMessage = 8;
 26
 27        /// <summary>The maximum number of bytes that a message may be to be considered small.</summary>
 28        private const byte MaximumBytesSmallMessage = 255;
 29
 30        /// <summary>The size of the batch, in bytes, to reserve for the AMQP message overhead.</summary>
 31        private readonly long _reservedSize;
 32
 33        /// <summary>A flag that indicates whether or not the instance has been disposed.</summary>
 34        private bool _disposed = false;
 35
 36        /// <summary>The size of the batch, in bytes, as it will be sent via the AMQP transport.</summary>
 37        private long _sizeBytes = 0;
 38
 39        /// <summary>
 40        ///   The maximum size allowed for the batch, in bytes.  This includes the messages in the batch as
 41        ///   well as any overhead for the batch itself when sent to the Queue/Topic.
 42        /// </summary>
 43        ///
 7244        public override long MaxSizeInBytes { get; }
 45
 46        /// <summary>
 47        ///   The size of the batch, in bytes, as it will be sent to the Queue/Topic
 48        ///   service.
 49        /// </summary>
 50        ///
 851        public override long SizeInBytes => _sizeBytes;
 52
 53        /// <summary>
 54        ///   The count of messages contained in the batch.
 55        /// </summary>
 56        ///
 1257        public override int Count => BatchMessages.Count;
 58
 59        /// <summary>
 60        ///   The set of options to apply to the batch.
 61        /// </summary>
 62        ///
 063        private CreateMessageBatchOptions Options { get; }
 64
 65        /// <summary>
 66        ///   The set of messages that have been added to the batch.
 67        /// </summary>
 68        ///
 12069        private List<ServiceBusMessage> BatchMessages { get; } = new List<ServiceBusMessage>();
 70
 71        /// <summary>
 72        ///   Initializes a new instance of the <see cref="AmqpMessageBatch"/> class.
 73        /// </summary>
 74        ///
 75        /// <param name="options">The set of options to apply to the batch.</param>
 76        ///
 3077        public AmqpMessageBatch(CreateMessageBatchOptions options)
 78        {
 3079            Argument.AssertNotNull(options, nameof(options));
 2880            Argument.AssertNotNull(options.MaxSizeInBytes, nameof(options.MaxSizeInBytes));
 81
 2682            Options = options;
 2683            MaxSizeInBytes = options.MaxSizeInBytes.Value;
 84
 85            // Initialize the size by reserving space for the batch envelope.
 86
 2687            using AmqpMessage envelope = AmqpMessageConverter.BatchSBMessagesAsAmqpMessage(Enumerable.Empty<ServiceBusMe
 2688            _reservedSize = envelope.SerializedMessageSize;
 2689            _sizeBytes = _reservedSize;
 5290        }
 91
 92        /// <summary>
 93        ///   Attempts to add a message to the batch, ensuring that the size
 94        ///   of the batch does not exceed its maximum.
 95        /// </summary>
 96        ///
 97        /// <param name="message">The message to attempt to add to the batch.</param>
 98        ///
 99        /// <returns><c>true</c> if the message was added; otherwise, <c>false</c>.</returns>
 100        ///
 101        public override bool TryAddMessage(ServiceBusMessage message)
 102        {
 74103            Argument.AssertNotNull(message, nameof(message));
 72104            Argument.AssertNotDisposed(_disposed, nameof(ServiceBusMessageBatch));
 105
 70106            AmqpMessage amqpMessage = AmqpMessageConverter.SBMessageToAmqpMessage(message);
 107
 108            try
 109            {
 110                // Calculate the size for the message, based on the AMQP message size and accounting for a
 111                // bit of reserved overhead size.
 112
 70113                var size = _sizeBytes
 70114                    + amqpMessage.SerializedMessageSize
 70115                    + (amqpMessage.SerializedMessageSize <= MaximumBytesSmallMessage
 70116                        ? OverheadBytesSmallMessage
 70117                        : OverheadBytesLargeMessage);
 118
 70119                if (size > MaxSizeInBytes)
 120                {
 4121                    return false;
 122                }
 123
 66124                _sizeBytes = size;
 66125                BatchMessages.Add(message);
 126
 66127            return true;
 128            }
 129            finally
 130            {
 70131                amqpMessage?.Dispose();
 70132            }
 70133        }
 134
 135        /// <summary>
 136        ///   Clears the batch, removing all messages and resetting the
 137        ///   available size.
 138        /// </summary>
 139        ///
 140        public override void Clear()
 141        {
 10142            BatchMessages.Clear();
 10143            _sizeBytes = _reservedSize;
 10144        }
 145
 146        /// <summary>
 147        ///   Represents the batch as an enumerable set of transport-specific
 148        ///   representations of a message.
 149        /// </summary>
 150        ///
 151        /// <typeparam name="T">The transport-specific message representation being requested.</typeparam>
 152        ///
 153        /// <returns>The set of messages as an enumerable of the requested type.</returns>
 154        ///
 155        public override IEnumerable<T> AsEnumerable<T>()
 156        {
 4157            if (typeof(T) != typeof(ServiceBusMessage))
 158            {
 2159                throw new FormatException(string.Format(CultureInfo.CurrentCulture, Resources.UnsupportedTransportEventT
 160            }
 161
 2162            return (IEnumerable<T>)BatchMessages;
 163        }
 164
 165        /// <summary>
 166        ///   Performs the task needed to clean up resources used by the <see cref="AmqpMessageBatch" />.
 167        /// </summary>
 168        ///
 169        public override void Dispose()
 170        {
 6171            _disposed = true;
 6172            Clear();
 6173        }
 174    }
 175}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:46:43 PM
GitHub | www.palmmedia.de

Methods/Properties

get_MaxSizeInBytes()
get_SizeInBytes()
get_Count()
get_Options()
get_BatchMessages()
.ctor(...)
TryAddMessage(...)
Clear()
AsEnumerable()
Dispose()