< Summary

Class:Azure.Messaging.ServiceBus.Management.CreateQueueOptions
Assembly:Azure.Messaging.ServiceBus
File(s):C:\Git\azure-sdk-for-net\sdk\servicebus\Azure.Messaging.ServiceBus\src\Management\CreateQueueOptions.cs
Covered lines:112
Uncovered lines:20
Coverable lines:132
Total lines:368
Line coverage:84.8% (112 of 132)
Covered branches:29
Total branches:66
Branch coverage:43.9% (29 of 66)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
.ctor(...)-100%100%
.ctor(...)-100%100%
get_Name()-100%100%
set_Name(...)-100%100%
get_LockDuration()-100%100%
set_LockDuration(...)-100%100%
get_MaxSizeInMegabytes()-100%100%
get_RequiresDuplicateDetection()-100%100%
get_RequiresSession()-100%100%
get_DefaultMessageTimeToLive()-100%100%
set_DefaultMessageTimeToLive(...)-100%100%
get_AutoDeleteOnIdle()-100%100%
set_AutoDeleteOnIdle(...)-100%100%
get_DeadLetteringOnMessageExpiration()-100%100%
get_DuplicateDetectionHistoryTimeWindow()-100%100%
set_DuplicateDetectionHistoryTimeWindow(...)-100%100%
get_MaxDeliveryCount()-100%100%
set_MaxDeliveryCount(...)-100%100%
get_EnableBatchedOperations()-100%100%
get_AuthorizationRules()-100%100%
get_Status()-100%100%
get_ForwardTo()-100%100%
set_ForwardTo(...)-37.5%25%
get_ForwardDeadLetteredMessagesTo()-100%100%
set_ForwardDeadLetteredMessagesTo(...)-37.5%25%
get_EnablePartitioning()-100%100%
get_UserMetadata()-100%100%
set_UserMetadata(...)-100%100%
GetHashCode()-0%0%
Equals(...)-0%100%
Equals(...)-95.45%52.08%
op_Equality(...)-0%0%
op_Inequality(...)-0%100%

File(s)

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

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4using System;
 5using Azure.Core;
 6
 7namespace Azure.Messaging.ServiceBus.Management
 8{
 9    /// <summary>
 10    /// Represents the set of options that can be specified for the creation of a queue.
 11    /// </summary>
 12    public class CreateQueueOptions : IEquatable<CreateQueueOptions>
 13    {
 3614        private TimeSpan _duplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(1);
 15        private string _name;
 3616        private TimeSpan _lockDuration = TimeSpan.FromSeconds(60);
 3617        private TimeSpan _defaultMessageTimeToLive = TimeSpan.MaxValue;
 3618        private TimeSpan autoDeleteOnIdle = TimeSpan.MaxValue;
 3619        private int _maxDeliveryCount = 10;
 20        private string _forwardTo = null;
 21        private string _forwardDeadLetteredMessagesTo = null;
 22        private string _userMetadata = null;
 23
 24        /// <summary>
 25        /// Initializes a new instance of <see cref="CreateQueueOptions"/> with the specified relative name.
 26        /// </summary>
 27        /// <param name="name">Name of the queue relative to the namespace base address.</param>
 2828        public CreateQueueOptions(string name)
 29        {
 2830            Name = name;
 2831        }
 32
 33        /// <summary>
 34        /// Initializes a new instance of <see cref="CreateQueueOptions"/> based on the
 35        /// specified <see cref="QueueProperties"/> instance. This is useful for creating a new queue based
 36        /// on the properties of an existing queue.
 37        /// </summary>
 38        /// <param name="queue">Existing queue to create options from.</param>
 839        public CreateQueueOptions(QueueProperties queue)
 40        {
 841            Argument.AssertNotNull(queue, nameof(queue));
 842            Name = queue.Name;
 843            LockDuration = queue.LockDuration;
 844            MaxSizeInMegabytes = queue.MaxSizeInMegabytes;
 845            RequiresDuplicateDetection = queue.RequiresDuplicateDetection;
 846            RequiresSession = queue.RequiresSession;
 847            DefaultMessageTimeToLive = queue.DefaultMessageTimeToLive;
 848            AutoDeleteOnIdle = queue.AutoDeleteOnIdle;
 849            DeadLetteringOnMessageExpiration = queue.DeadLetteringOnMessageExpiration;
 850            DuplicateDetectionHistoryTimeWindow = queue.DuplicateDetectionHistoryTimeWindow;
 851            MaxDeliveryCount = queue.MaxDeliveryCount;
 852            EnableBatchedOperations = queue.EnableBatchedOperations;
 853            AuthorizationRules = queue.AuthorizationRules.Clone();
 854            Status = queue.Status;
 855            ForwardTo = queue.ForwardTo;
 856            ForwardDeadLetteredMessagesTo = queue.ForwardDeadLetteredMessagesTo;
 857            EnablePartitioning = queue.EnablePartitioning;
 858            if (queue.UserMetadata != null)
 59            {
 460                UserMetadata = queue.UserMetadata;
 61            }
 862        }
 63
 64        /// <summary>
 65        /// Name of the queue relative to the namespace base address.
 66        /// </summary>
 67        /// <remarks>Max length is 260 chars. Cannot start or end with a slash.
 68        /// Cannot have restricted characters: '@','?','#','*'</remarks>
 69        public string Name
 70        {
 4871            get => _name;
 72            set
 73            {
 4474                EntityNameFormatter.CheckValidQueueName(value, nameof(Name));
 4075                _name = value;
 4076            }
 77        }
 78
 79        /// <summary>
 80        /// Duration of a peek lock receive. i.e., the amount of time that the message is locked by a given receiver so 
 81        /// no other receiver receives the same message.
 82        /// </summary>
 83        /// <remarks>Max value is 5 minutes. Default value is 60 seconds.</remarks>
 84        public TimeSpan LockDuration
 85        {
 3686            get => _lockDuration;
 87            set
 88            {
 1289                Argument.AssertPositive(value, nameof(LockDuration));
 1290                _lockDuration = value;
 1291            }
 92        }
 93
 94        /// <summary>
 95        /// The maximum size of the queue in megabytes, which is the size of memory allocated for the queue.
 96        /// </summary>
 97        /// <remarks>Default value is 1024.</remarks>
 8498        public long MaxSizeInMegabytes { get; set; } = 1024;
 99
 100        /// <summary>
 101        /// This value indicates if the queue requires guard against duplicate messages. If true, duplicate messages hav
 102        /// <see cref="ServiceBusMessage.MessageId"/> and sent to queue within duration of <see cref="DuplicateDetection
 103        /// will be discarded.
 104        /// </summary>
 105        /// <remarks>Defaults to false.</remarks>
 56106        public bool RequiresDuplicateDetection { get; set; } = false;
 107
 108        /// <summary>
 109        /// This indicates whether the queue supports the concept of session. Sessionful-messages follow FIFO ordering.
 110        /// </summary>
 111        /// <remarks>
 112        /// If true, the receiver can only receive messages using <see cref="ServiceBusSessionReceiver"/>.
 113        /// Defaults to false.
 114        /// </remarks>
 48115        public bool RequiresSession { get; set; } = false;
 116
 117        /// <summary>
 118        /// The default time to live value for the messages. This is the duration after which the message expires, start
 119        /// the message is sent to Service Bus. </summary>
 120        /// <remarks>
 121        /// This is the default value used when <see cref="ServiceBusMessage.TimeToLive"/> is not set on a
 122        ///  message itself. Messages older than their TimeToLive value will expire and no longer be retained in the mes
 123        ///  Subscribers will be unable to receive expired messages.
 124        ///  Default value is <see cref="TimeSpan.MaxValue"/>.
 125        ///  </remarks>
 126        public TimeSpan DefaultMessageTimeToLive
 127        {
 36128            get => _defaultMessageTimeToLive;
 129            set
 130            {
 12131                Argument.AssertInRange(
 12132                    value,
 12133                    ManagementClientConstants.MinimumAllowedTimeToLive,
 12134                    ManagementClientConstants.MaximumAllowedTimeToLive,
 12135                    nameof(DefaultMessageTimeToLive));
 136
 12137                _defaultMessageTimeToLive = value;
 12138            }
 139        }
 140
 141        /// <summary>
 142        /// The <see cref="TimeSpan"/> idle interval after which the queue is automatically deleted.
 143        /// </summary>
 144        /// <remarks>The minimum duration is 5 minutes. Default value is <see cref="TimeSpan.MaxValue"/>.</remarks>
 145        public TimeSpan AutoDeleteOnIdle
 146        {
 36147            get => autoDeleteOnIdle;
 148            set
 149            {
 12150                Argument.AssertAtLeast(
 12151                    value,
 12152                    ManagementClientConstants.MinimumAllowedAutoDeleteOnIdle,
 12153                    nameof(AutoDeleteOnIdle));
 154
 12155                autoDeleteOnIdle = value;
 12156            }
 157        }
 158
 159        /// <summary>
 160        /// Indicates whether this queue has dead letter support when a message expires.
 161        /// </summary>
 162        /// <remarks>If true, the expired messages are moved to dead-letter sub-queue. Default value is false.</remarks>
 48163        public bool DeadLetteringOnMessageExpiration { get; set; } = false;
 164
 165        /// <summary>
 166        /// The <see cref="TimeSpan"/> duration of duplicate detection history that is maintained by the service.
 167        /// </summary>
 168        /// <remarks>
 169        /// The default value is 1 minute. Max value is 7 days and minimum is 20 seconds.
 170        /// </remarks>
 171        public TimeSpan DuplicateDetectionHistoryTimeWindow
 172        {
 28173            get => _duplicateDetectionHistoryTimeWindow;
 174            set
 175            {
 12176                Argument.AssertInRange(
 12177                    value,
 12178                    ManagementClientConstants.MinimumDuplicateDetectionHistoryTimeWindow,
 12179                    ManagementClientConstants.MaximumDuplicateDetectionHistoryTimeWindow,
 12180                    nameof(DuplicateDetectionHistoryTimeWindow));
 181
 12182                _duplicateDetectionHistoryTimeWindow = value;
 12183            }
 184        }
 185
 186        /// <summary>
 187        /// The maximum delivery count of a message before it is dead-lettered.
 188        /// </summary>
 189        /// <remarks>The delivery count is increased when a message is received in <see cref="ReceiveMode.PeekLock"/> mo
 190        /// and didn't complete the message before the message lock expired.
 191        /// Default value is 10. Minimum value is 1.</remarks>
 192        public int MaxDeliveryCount
 193        {
 36194            get => _maxDeliveryCount;
 195            set
 196            {
 12197                Argument.AssertAtLeast(
 12198                    value,
 12199                    ManagementClientConstants.MinAllowedMaxDeliveryCount,
 12200                    nameof(MaxDeliveryCount));
 201
 12202                _maxDeliveryCount = value;
 12203            }
 204        }
 205
 206        /// <summary>
 207        /// Indicates whether server-side batched operations are enabled.
 208        /// </summary>
 209        /// <remarks>Defaults to true.</remarks>
 104210        public bool EnableBatchedOperations { get; set; } = true;
 211
 212        /// <summary>
 213        /// The <see cref="AuthorizationRules"/> on the queue to control user access at entity level.
 214        /// </summary>
 116215        public AuthorizationRules AuthorizationRules { get; internal set; } = new AuthorizationRules();
 216
 217        /// <summary>
 218        /// The current status of the queue (Enabled / Disabled).
 219        /// </summary>
 220        /// <remarks>When an entity is disabled, that entity cannot send or receive messages.</remarks>
 84221        public EntityStatus Status { get; set; } = EntityStatus.Active;
 222
 223        /// <summary>
 224        /// The name of the recipient entity to which all the messages sent to the queue are forwarded to.
 225        /// </summary>
 226        /// <remarks>If set, user cannot manually receive messages from this queue. The destination entity
 227        /// must be an already existing entity.</remarks>
 228        public string ForwardTo
 229        {
 36230            get => _forwardTo;
 231            set
 232            {
 12233                if (string.IsNullOrWhiteSpace(value))
 234                {
 12235                    _forwardTo = value;
 12236                    return;
 237                }
 238
 0239                EntityNameFormatter.CheckValidQueueName(value, nameof(ForwardTo));
 0240                if (_name.Equals(value, StringComparison.CurrentCultureIgnoreCase))
 241
 242                {
 0243                    throw new InvalidOperationException("Entity cannot have auto-forwarding policy to itself");
 244                }
 245
 0246                _forwardTo = value;
 0247            }
 248        }
 249
 250        /// <summary>
 251        /// The name of the recipient entity to which all the dead-lettered messages of this queue are forwarded to.
 252        /// </summary>
 253        /// <remarks>If set, user cannot manually receive dead-lettered messages from this queue. The destination
 254        /// entity must already exist.</remarks>
 255        public string ForwardDeadLetteredMessagesTo
 256        {
 36257            get => _forwardDeadLetteredMessagesTo;
 258            set
 259            {
 12260                if (string.IsNullOrWhiteSpace(value))
 261                {
 12262                    _forwardDeadLetteredMessagesTo = value;
 12263                    return;
 264                }
 265
 0266                EntityNameFormatter.CheckValidQueueName(value, nameof(ForwardDeadLetteredMessagesTo));
 0267                if (_name.Equals(value, StringComparison.CurrentCultureIgnoreCase))
 268                {
 0269                    throw new InvalidOperationException("Entity cannot have auto-forwarding policy to itself");
 270                }
 271
 0272                _forwardDeadLetteredMessagesTo = value;
 0273            }
 274        }
 275
 276        /// <summary>
 277        /// Indicates whether the queue is to be partitioned across multiple message brokers.
 278        /// </summary>
 279        /// <remarks>Defaults to false.</remarks>
 28280        public bool EnablePartitioning { get; set; } = false;
 281
 282        /// <summary>
 283        /// Custom metdata that user can associate with the queue.
 284        /// </summary>
 285        /// <remarks>Cannot be null. Max length is 1024 chars.</remarks>
 286        public string UserMetadata
 287        {
 24288            get => _userMetadata;
 289            set
 290            {
 8291                Argument.AssertNotNull(value, nameof(UserMetadata));
 8292                Argument.AssertNotTooLong(
 8293                    value,
 8294                    ManagementClientConstants.MaxUserMetadataLength,
 8295                    nameof(UserMetadata));
 296
 8297                _userMetadata = value;
 8298            }
 299        }
 300
 301        /// <summary>
 302        ///   Returns a hash code for this instance.
 303        /// </summary>
 304        public override int GetHashCode()
 305        {
 0306            return Name?.GetHashCode() ?? base.GetHashCode();
 307        }
 308
 309        /// <summary>Determines whether the specified object is equal to the current object.</summary>
 310        public override bool Equals(object obj)
 311        {
 0312            var other = obj as CreateQueueOptions;
 0313            return Equals(other);
 314        }
 315
 316        /// <summary>Determines whether the specified object is equal to the current object.</summary>
 317        public bool Equals(CreateQueueOptions other)
 318        {
 8319            if (other is CreateQueueOptions otherOptions
 8320                && Name.Equals(otherOptions.Name, StringComparison.OrdinalIgnoreCase)
 8321                && AutoDeleteOnIdle.Equals(otherOptions.AutoDeleteOnIdle)
 8322                && DefaultMessageTimeToLive.Equals(otherOptions.DefaultMessageTimeToLive)
 8323                && (!RequiresDuplicateDetection || DuplicateDetectionHistoryTimeWindow.Equals(otherOptions.DuplicateDete
 8324                && EnableBatchedOperations == otherOptions.EnableBatchedOperations
 8325                && DeadLetteringOnMessageExpiration == otherOptions.DeadLetteringOnMessageExpiration
 8326                && EnablePartitioning == otherOptions.EnablePartitioning
 8327                && string.Equals(ForwardDeadLetteredMessagesTo, otherOptions.ForwardDeadLetteredMessagesTo, StringCompar
 8328                && string.Equals(ForwardTo, otherOptions.ForwardTo, StringComparison.OrdinalIgnoreCase)
 8329                && LockDuration.Equals(otherOptions.LockDuration)
 8330                && MaxDeliveryCount == otherOptions.MaxDeliveryCount
 8331                && MaxSizeInMegabytes == otherOptions.MaxSizeInMegabytes
 8332                && RequiresDuplicateDetection.Equals(otherOptions.RequiresDuplicateDetection)
 8333                && RequiresSession.Equals(otherOptions.RequiresSession)
 8334                && Status.Equals(otherOptions.Status)
 8335                && string.Equals(_userMetadata, otherOptions._userMetadata, StringComparison.OrdinalIgnoreCase)
 8336                && (AuthorizationRules != null && otherOptions.AuthorizationRules != null
 8337                    || AuthorizationRules == null && otherOptions.AuthorizationRules == null)
 8338                && (AuthorizationRules == null || AuthorizationRules.Equals(otherOptions.AuthorizationRules)))
 339            {
 8340                return true;
 341            }
 342
 0343            return false;
 344        }
 345
 346        /// <summary></summary>
 347        public static bool operator ==(CreateQueueOptions left, CreateQueueOptions right)
 348        {
 0349            if (ReferenceEquals(left, right))
 350            {
 0351                return true;
 352            }
 353
 0354            if (left is null || right is null)
 355            {
 0356                return false;
 357            }
 358
 0359            return left.Equals(right);
 360        }
 361
 362        /// <summary></summary>
 363        public static bool operator !=(CreateQueueOptions left, CreateQueueOptions right)
 364        {
 0365            return !(left == right);
 366        }
 367    }
 368}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:46:43 PM
GitHub | www.palmmedia.de

Methods/Properties

.ctor(...)
.ctor(...)
get_Name()
set_Name(...)
get_LockDuration()
set_LockDuration(...)
get_MaxSizeInMegabytes()
get_RequiresDuplicateDetection()
get_RequiresSession()
get_DefaultMessageTimeToLive()
set_DefaultMessageTimeToLive(...)
get_AutoDeleteOnIdle()
set_AutoDeleteOnIdle(...)
get_DeadLetteringOnMessageExpiration()
get_DuplicateDetectionHistoryTimeWindow()
set_DuplicateDetectionHistoryTimeWindow(...)
get_MaxDeliveryCount()
set_MaxDeliveryCount(...)
get_EnableBatchedOperations()
get_AuthorizationRules()
get_Status()
get_ForwardTo()
set_ForwardTo(...)
get_ForwardDeadLetteredMessagesTo()
set_ForwardDeadLetteredMessagesTo(...)
get_EnablePartitioning()
get_UserMetadata()
set_UserMetadata(...)
GetHashCode()
Equals(...)
Equals(...)
op_Equality(...)
op_Inequality(...)