* IComparable for AmqpString

lukebakken · lukebakken · commit d4490e2578cb · 2024-05-17T09:21:53.000-07:00
* Replace more use of `string` with `QueueName`
diff --git a/projects/RabbitMQ.Client/PublicAPI.Unshipped.txt b/projects/RabbitMQ.Client/PublicAPI.Unshipped.txt
@@ -314,7 +314,6 @@ RabbitMQ.Client.Events.EventingBasicConsumer.Unregistered -> System.EventHandler
 RabbitMQ.Client.Events.FlowControlEventArgs
 RabbitMQ.Client.Events.FlowControlEventArgs.FlowControlEventArgs(bool active) -> void
 RabbitMQ.Client.Events.QueueNameChangedAfterRecoveryEventArgs
-RabbitMQ.Client.Events.QueueNameChangedAfterRecoveryEventArgs.QueueNameChangedAfterRecoveryEventArgs(string nameBefore, string nameAfter) -> void
 RabbitMQ.Client.Events.RecoveringConsumerEventArgs
 RabbitMQ.Client.Events.RecoveringConsumerEventArgs.ConsumerArguments.get -> System.Collections.Generic.IDictionary<string, object>
 RabbitMQ.Client.Events.RecoveringConsumerEventArgs.ConsumerTag.get -> string
@@ -814,8 +813,6 @@ readonly RabbitMQ.Client.Events.ConsumerEventArgs.ConsumerTags -> string[]
 readonly RabbitMQ.Client.Events.ConsumerTagChangedAfterRecoveryEventArgs.TagAfter -> string
 readonly RabbitMQ.Client.Events.ConsumerTagChangedAfterRecoveryEventArgs.TagBefore -> string
 readonly RabbitMQ.Client.Events.FlowControlEventArgs.Active -> bool
-readonly RabbitMQ.Client.Events.QueueNameChangedAfterRecoveryEventArgs.NameAfter -> string
-readonly RabbitMQ.Client.Events.QueueNameChangedAfterRecoveryEventArgs.NameBefore -> string
 readonly RabbitMQ.Client.Exceptions.HardProtocolException._canShutdownCleanly -> bool
 readonly RabbitMQ.Client.QueueDeclareOk.ConsumerCount -> uint
 readonly RabbitMQ.Client.QueueDeclareOk.MessageCount -> uint
@@ -878,6 +875,7 @@ virtual RabbitMQ.Client.TcpClientAdapter.ReceiveTimeout.set -> void
 ~override RabbitMQ.Client.ExchangeType.ToString() -> string
 ~RabbitMQ.Client.AmqpString.AmqpString(string value, ushort maxLen, System.Text.Encoding encoding) -> void
 ~RabbitMQ.Client.AmqpString.AmqpString(string value, ushort maxLen, System.Text.Encoding encoding, string validatorRegex) -> void
+~RabbitMQ.Client.AmqpString.CompareTo(RabbitMQ.Client.AmqpString other) -> int
 ~RabbitMQ.Client.AmqpString.Contains(string value) -> bool
 ~RabbitMQ.Client.AmqpString.Equals(RabbitMQ.Client.AmqpString other) -> bool
 ~RabbitMQ.Client.AmqpTcpEndpoint.AmqpTcpEndpoint(string hostName, int portOrMinusOne, RabbitMQ.Client.SslOption ssl, uint maxInboundMessageBodySize) -> void
@@ -890,6 +888,7 @@ virtual RabbitMQ.Client.TcpClientAdapter.ReceiveTimeout.set -> void
 ~RabbitMQ.Client.ConnectionFactory.CreateConnectionAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<RabbitMQ.Client.IConnection>
 ~RabbitMQ.Client.ConsumerTag.ConsumerTag(string exchangeName) -> void
 ~RabbitMQ.Client.Events.BasicDeliverEventArgs.BasicDeliverEventArgs(string consumerTag, ulong deliveryTag, bool redelivered, System.ReadOnlyMemory<byte> exchange, System.ReadOnlyMemory<byte> routingKey, in RabbitMQ.Client.ReadOnlyBasicProperties properties, System.ReadOnlyMemory<byte> body) -> void
+~RabbitMQ.Client.Events.QueueNameChangedAfterRecoveryEventArgs.QueueNameChangedAfterRecoveryEventArgs(RabbitMQ.Client.QueueName nameBefore, RabbitMQ.Client.QueueName nameAfter) -> void
 ~RabbitMQ.Client.ExchangeName.ExchangeName(string exchangeName) -> void
 ~RabbitMQ.Client.ExchangeType.Equals(RabbitMQ.Client.ExchangeType other) -> bool
 ~RabbitMQ.Client.IAsyncBasicConsumer.HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, System.ReadOnlyMemory<byte> exchange, System.ReadOnlyMemory<byte> routingKey, in RabbitMQ.Client.ReadOnlyBasicProperties properties, System.ReadOnlyMemory<byte> body) -> System.Threading.Tasks.Task
@@ -943,14 +942,16 @@ virtual RabbitMQ.Client.TcpClientAdapter.ReceiveTimeout.set -> void
 ~RabbitMQ.Client.TopologyRecoveryExceptionHandler.ExchangeRecoveryExceptionHandlerAsync.set -> void
 ~RabbitMQ.Client.TopologyRecoveryExceptionHandler.QueueRecoveryExceptionHandlerAsync.get -> System.Func<RabbitMQ.Client.IRecordedQueue, System.Exception, RabbitMQ.Client.IConnection, System.Threading.Tasks.Task>
 ~RabbitMQ.Client.TopologyRecoveryExceptionHandler.QueueRecoveryExceptionHandlerAsync.set -> void
+~readonly RabbitMQ.Client.Events.QueueNameChangedAfterRecoveryEventArgs.NameAfter -> RabbitMQ.Client.QueueName
+~readonly RabbitMQ.Client.Events.QueueNameChangedAfterRecoveryEventArgs.NameBefore -> RabbitMQ.Client.QueueName
 ~readonly RabbitMQ.Client.PublicationAddress.ExchangeName -> RabbitMQ.Client.ExchangeName
 ~readonly RabbitMQ.Client.PublicationAddress.ExchangeType -> RabbitMQ.Client.ExchangeType
 ~readonly RabbitMQ.Client.PublicationAddress.RoutingKey -> RabbitMQ.Client.RoutingKey
 ~static RabbitMQ.Client.AmqpString.implicit operator string(RabbitMQ.Client.AmqpString amqpString) -> string
 ~static RabbitMQ.Client.AmqpString.implicit operator System.ReadOnlyMemory<byte>(RabbitMQ.Client.AmqpString amqpString) -> System.ReadOnlyMemory<byte>
 ~static RabbitMQ.Client.AmqpString.implicit operator System.ReadOnlySpan<byte>(RabbitMQ.Client.AmqpString amqpString) -> System.ReadOnlySpan<byte>
-~static RabbitMQ.Client.AmqpString.operator !=(RabbitMQ.Client.AmqpString exchangeType1, RabbitMQ.Client.AmqpString exchangeType2) -> bool
-~static RabbitMQ.Client.AmqpString.operator ==(RabbitMQ.Client.AmqpString exchangeType1, RabbitMQ.Client.AmqpString exchangeType2) -> bool
+~static RabbitMQ.Client.AmqpString.operator !=(RabbitMQ.Client.AmqpString amqpString1, RabbitMQ.Client.AmqpString amqpString2) -> bool
+~static RabbitMQ.Client.AmqpString.operator ==(RabbitMQ.Client.AmqpString amqpString1, RabbitMQ.Client.AmqpString amqpString2) -> bool
 ~static RabbitMQ.Client.ConsumerTag.implicit operator RabbitMQ.Client.ConsumerTag(string value) -> RabbitMQ.Client.ConsumerTag
 ~static RabbitMQ.Client.ExchangeName.implicit operator RabbitMQ.Client.ExchangeName(string value) -> RabbitMQ.Client.ExchangeName
 ~static RabbitMQ.Client.ExchangeType.implicit operator RabbitMQ.Client.ExchangeType(string value) -> RabbitMQ.Client.ExchangeType
diff --git a/projects/RabbitMQ.Client/client/api/AmqpString.cs b/projects/RabbitMQ.Client/client/api/AmqpString.cs
@@ -36,7 +36,7 @@
 namespace RabbitMQ.Client
 {
     // TODO lazy string value
-    public abstract class AmqpString : IEquatable<AmqpString>
+    public abstract class AmqpString : IEquatable<AmqpString>, IComparable<AmqpString>
     {
         private readonly string _value;
         private readonly ReadOnlyMemory<byte> _stringBytes;
@@ -153,24 +153,36 @@ public override int GetHashCode()
             return _value.GetHashCode();
         }
 
-        public static bool operator ==(AmqpString exchangeType1, AmqpString exchangeType2)
+        public int CompareTo(AmqpString other)
         {
-            if (exchangeType1 is null || exchangeType2 is null)
+            if (_value is null)
             {
-                return Object.Equals(exchangeType1, exchangeType2);
+                throw new InvalidOperationException("[CRITICAL] should not see this");
+            }
+            else
+            {
+                return _value.CompareTo(other._value);
+            }
+        }
+
+        public static bool operator ==(AmqpString amqpString1, AmqpString amqpString2)
+        {
+            if (amqpString1 is null || amqpString2 is null)
+            {
+                return Object.Equals(amqpString1, amqpString2);
             }
 
-            return exchangeType1.Equals(exchangeType2);
+            return amqpString1.Equals(amqpString2);
         }
 
-        public static bool operator !=(AmqpString exchangeType1, AmqpString exchangeType2)
+        public static bool operator !=(AmqpString amqpString1, AmqpString amqpString2)
         {
-            if (exchangeType1 is null || exchangeType2 is null)
+            if (amqpString1 is null || amqpString2 is null)
             {
-                return false == Object.Equals(exchangeType1, exchangeType2);
+                return false == Object.Equals(amqpString1, amqpString2);
             }
 
-            return false == exchangeType1.Equals(exchangeType2);
+            return false == amqpString1.Equals(amqpString2);
         }
     }
 
diff --git a/projects/RabbitMQ.Client/client/events/QueueNameChangedAfterRecoveryEventArgs.cs b/projects/RabbitMQ.Client/client/events/QueueNameChangedAfterRecoveryEventArgs.cs
@@ -40,7 +40,7 @@ public sealed class QueueNameChangedAfterRecoveryEventArgs : EventArgs
         /// </summary>
         /// <param name="nameBefore">The name before.</param>
         /// <param name="nameAfter">The name after.</param>
-        public QueueNameChangedAfterRecoveryEventArgs(string nameBefore, string nameAfter)
+        public QueueNameChangedAfterRecoveryEventArgs(QueueName nameBefore, QueueName nameAfter)
         {
             NameBefore = nameBefore;
             NameAfter = nameAfter;
@@ -49,11 +49,11 @@ public QueueNameChangedAfterRecoveryEventArgs(string nameBefore, string nameAfte
         /// <summary>
         /// Gets the name before.
         /// </summary>
-        public readonly string NameBefore;
+        public readonly QueueName NameBefore;
 
         /// <summary>
         /// Gets the name after.
         /// </summary>
-        public readonly string NameAfter;
+        public readonly QueueName NameAfter;
     }
 }
diff --git a/projects/RabbitMQ.Client/client/impl/AutorecoveringChannel.cs b/projects/RabbitMQ.Client/client/impl/AutorecoveringChannel.cs
@@ -389,7 +389,7 @@ public async Task<QueueDeclareOk> QueueDeclareAsync(QueueName queue, bool durabl
                 .ConfigureAwait(false);
             if (false == passive)
             {
-                var recordedQueue = new RecordedQueue((QueueName)result.QueueName, queue.IsEmpty, durable, exclusive, autoDelete, arguments);
+                var recordedQueue = new RecordedQueue((QueueName)result, queue.IsEmpty, durable, exclusive, autoDelete, arguments);
                 await _connection.RecordQueueAsync(recordedQueue, recordedEntitiesSemaphoreHeld: false, cancellationToken)
                     .ConfigureAwait(false);
             }
diff --git a/projects/RabbitMQ.Client/client/impl/AutorecoveringConnection.Recording.cs b/projects/RabbitMQ.Client/client/impl/AutorecoveringConnection.Recording.cs
@@ -244,7 +244,7 @@ await DoDeleteRecordedQueueAsync(queueName, cancellationToken)
                 }
             }
 
-            async ValueTask DoDeleteRecordedQueueAsync(string queueName, CancellationToken cancellationToken)
+            async ValueTask DoDeleteRecordedQueueAsync(QueueName queueName, CancellationToken cancellationToken)
             {
                 _recordedQueues.Remove(queueName);
 
@@ -366,7 +366,7 @@ private void DoRecordConsumer(in RecordedConsumer consumer)
             _recordedConsumers[consumer.ConsumerTag] = consumer;
         }
 
-        internal async ValueTask DeleteRecordedConsumerAsync(string consumerTag,
+        internal async ValueTask DeleteRecordedConsumerAsync(ConsumerTag consumerTag,
             bool recordedEntitiesSemaphoreHeld)
         {
             if (_disposed)
diff --git a/projects/RabbitMQ.Client/client/impl/AutorecoveringConnection.Recovery.cs b/projects/RabbitMQ.Client/client/impl/AutorecoveringConnection.Recovery.cs
@@ -317,20 +317,20 @@ private async Task RecoverQueuesAsync(IConnection connection,
                 throw new InvalidOperationException("recordedEntitiesSemaphore must be held");
             }
 
-            foreach (RecordedQueue recordedQueue in _recordedQueues.Values.Where(x => _config.TopologyRecoveryFilter?.QueueFilter(x) ?? true).ToArray())
+            foreach (RecordedQueue recordedQueue in _recordedQueues.Values.Where(x =>
+                _config.TopologyRecoveryFilter?.QueueFilter(x) ?? true).ToArray())
             {
                 try
                 {
-                    string newNameStr = string.Empty;
+                    QueueName newName;
                     using (IChannel ch = await connection.CreateChannelAsync(cancellationToken).ConfigureAwait(false))
                     {
-                        newNameStr = await recordedQueue.RecoverAsync(ch, cancellationToken)
+                        newName = await recordedQueue.RecoverAsync(ch, cancellationToken)
                             .ConfigureAwait(false);
                         await ch.CloseAsync(cancellationToken)
                             .ConfigureAwait(false);
                     }
                     QueueName oldName = recordedQueue.Name;
-                    QueueName newName = (QueueName)newNameStr;
 
                     if (oldName != newName)
                     {
@@ -358,7 +358,7 @@ await RecordQueueAsync(new RecordedQueue(newName, recordedQueue),
                             try
                             {
                                 _recordedEntitiesSemaphore.Release();
-                                _queueNameChangedAfterRecoveryWrapper.Invoke(this, new QueueNameChangedAfterRecoveryEventArgs(oldName, newNameStr));
+                                _queueNameChangedAfterRecoveryWrapper.Invoke(this, new QueueNameChangedAfterRecoveryEventArgs(oldName, newName));
                             }
                             finally
                             {
diff --git a/projects/RabbitMQ.Client/client/impl/RecordedQueue.cs b/projects/RabbitMQ.Client/client/impl/RecordedQueue.cs
@@ -73,16 +73,20 @@ public RecordedQueue(QueueName newName, in RecordedQueue old)
             _arguments = old._arguments;
         }
 
-        public Task<QueueDeclareOk> RecoverAsync(IChannel channel, CancellationToken cancellationToken)
+        public async Task<QueueName> RecoverAsync(IChannel channel, CancellationToken cancellationToken)
         {
             QueueName queueName = _name;
             if (_name.IsEmpty)
             {
                 queueName = QueueName.Empty;
             }
-            return channel.QueueDeclareAsync(queue: queueName, passive: false,
+
+            QueueDeclareOk queueDeclareResult = await channel.QueueDeclareAsync(queue: queueName, passive: false,
                 durable: _durable, exclusive: _exclusive, autoDelete: AutoDelete, arguments: _arguments,
-                cancellationToken: cancellationToken);
+                cancellationToken: cancellationToken)
+                    .ConfigureAwait(false);
+
+            return new QueueName(queueDeclareResult.QueueName);
         }
 
         public override string ToString()

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@`
`36`	`36`	`namespace RabbitMQ.Client`
`37`	`37`	`{`
`38`	`38`	`// TODO lazy string value`
`39`		`- public abstract class AmqpString : IEquatable<AmqpString>`
	`39`	`+ public abstract class AmqpString : IEquatable<AmqpString>, IComparable<AmqpString>`
`40`	`40`	`{`
`41`	`41`	`private readonly string _value;`
`42`	`42`	`private readonly ReadOnlyMemory<byte> _stringBytes;`
`@@ -153,24 +153,36 @@ public override int GetHashCode()`
`153`	`153`	`return _value.GetHashCode();`
`154`	`154`	`}`
`155`	`155`
`156`		`- public static bool operator ==(AmqpString exchangeType1, AmqpString exchangeType2)`
	`156`	`+ public int CompareTo(AmqpString other)`
`157`	`157`	`{`
`158`		`- if (exchangeType1 is null \|\| exchangeType2 is null)`
	`158`	`+ if (_value is null)`
`159`	`159`	`{`
`160`		`- return Object.Equals(exchangeType1, exchangeType2);`
	`160`	`+ throw new InvalidOperationException("[CRITICAL] should not see this");`
	`161`	`+ }`
	`162`	`+ else`
	`163`	`+ {`
	`164`	`+ return _value.CompareTo(other._value);`
	`165`	`+ }`
	`166`	`+ }`
	`167`	`+`
	`168`	`+ public static bool operator ==(AmqpString amqpString1, AmqpString amqpString2)`
	`169`	`+ {`
	`170`	`+ if (amqpString1 is null \|\| amqpString2 is null)`
	`171`	`+ {`
	`172`	`+ return Object.Equals(amqpString1, amqpString2);`
`161`	`173`	`}`
`162`	`174`
`163`		`- return exchangeType1.Equals(exchangeType2);`
	`175`	`+ return amqpString1.Equals(amqpString2);`
`164`	`176`	`}`
`165`	`177`
`166`		`- public static bool operator !=(AmqpString exchangeType1, AmqpString exchangeType2)`
	`178`	`+ public static bool operator !=(AmqpString amqpString1, AmqpString amqpString2)`
`167`	`179`	`{`
`168`		`- if (exchangeType1 is null \|\| exchangeType2 is null)`
	`180`	`+ if (amqpString1 is null \|\| amqpString2 is null)`
`169`	`181`	`{`
`170`		`- return false == Object.Equals(exchangeType1, exchangeType2);`
	`182`	`+ return false == Object.Equals(amqpString1, amqpString2);`
`171`	`183`	`}`
`172`	`184`
`173`		`- return false == exchangeType1.Equals(exchangeType2);`
	`185`	`+ return false == amqpString1.Equals(amqpString2);`
`174`	`186`	`}`
`175`	`187`	`}`
`176`	`188`
Original file line number	Diff line number	Diff line change
`@@ -389,7 +389,7 @@ public async Task<QueueDeclareOk> QueueDeclareAsync(QueueName queue, bool durabl`
`389`	`389`	`.ConfigureAwait(false);`
`390`	`390`	`if (false == passive)`
`391`	`391`	`{`
`392`		`- var recordedQueue = new RecordedQueue((QueueName)result.QueueName, queue.IsEmpty, durable, exclusive, autoDelete, arguments);`
	`392`	`+ var recordedQueue = new RecordedQueue((QueueName)result, queue.IsEmpty, durable, exclusive, autoDelete, arguments);`
`393`	`393`	`await _connection.RecordQueueAsync(recordedQueue, recordedEntitiesSemaphoreHeld: false, cancellationToken)`
`394`	`394`	`.ConfigureAwait(false);`
`395`	`395`	`}`
Original file line number	Diff line number	Diff line change
`@@ -244,7 +244,7 @@ await DoDeleteRecordedQueueAsync(queueName, cancellationToken)`
`244`	`244`	`}`
`245`	`245`	`}`
`246`	`246`
`247`		`- async ValueTask DoDeleteRecordedQueueAsync(string queueName, CancellationToken cancellationToken)`
	`247`	`+ async ValueTask DoDeleteRecordedQueueAsync(QueueName queueName, CancellationToken cancellationToken)`
`248`	`248`	`{`
`249`	`249`	`_recordedQueues.Remove(queueName);`
`250`	`250`
`@@ -366,7 +366,7 @@ private void DoRecordConsumer(in RecordedConsumer consumer)`
`366`	`366`	`_recordedConsumers[consumer.ConsumerTag] = consumer;`
`367`	`367`	`}`
`368`	`368`
`369`		`- internal async ValueTask DeleteRecordedConsumerAsync(string consumerTag,`
	`369`	`+ internal async ValueTask DeleteRecordedConsumerAsync(ConsumerTag consumerTag,`
`370`	`370`	`bool recordedEntitiesSemaphoreHeld)`
`371`	`371`	`{`
`372`	`372`	`if (_disposed)`
Original file line number	Diff line number	Diff line change
`@@ -317,20 +317,20 @@ private async Task RecoverQueuesAsync(IConnection connection,`
`317`	`317`	`throw new InvalidOperationException("recordedEntitiesSemaphore must be held");`
`318`	`318`	`}`
`319`	`319`
`320`		`- foreach (RecordedQueue recordedQueue in _recordedQueues.Values.Where(x => _config.TopologyRecoveryFilter?.QueueFilter(x) ?? true).ToArray())`
	`320`	`+ foreach (RecordedQueue recordedQueue in _recordedQueues.Values.Where(x =>`
	`321`	`+ _config.TopologyRecoveryFilter?.QueueFilter(x) ?? true).ToArray())`
`321`	`322`	`{`
`322`	`323`	`try`
`323`	`324`	`{`
`324`		`- string newNameStr = string.Empty;`
	`325`	`+ QueueName newName;`
`325`	`326`	`using (IChannel ch = await connection.CreateChannelAsync(cancellationToken).ConfigureAwait(false))`
`326`	`327`	`{`
`327`		`- newNameStr = await recordedQueue.RecoverAsync(ch, cancellationToken)`
	`328`	`+ newName = await recordedQueue.RecoverAsync(ch, cancellationToken)`
`328`	`329`	`.ConfigureAwait(false);`
`329`	`330`	`await ch.CloseAsync(cancellationToken)`
`330`	`331`	`.ConfigureAwait(false);`
`331`	`332`	`}`
`332`	`333`	`QueueName oldName = recordedQueue.Name;`
`333`		`- QueueName newName = (QueueName)newNameStr;`
`334`	`334`
`335`	`335`	`if (oldName != newName)`
`336`	`336`	`{`
`@@ -358,7 +358,7 @@ await RecordQueueAsync(new RecordedQueue(newName, recordedQueue),`
`358`	`358`	`try`
`359`	`359`	`{`
`360`	`360`	`_recordedEntitiesSemaphore.Release();`
`361`		`- _queueNameChangedAfterRecoveryWrapper.Invoke(this, new QueueNameChangedAfterRecoveryEventArgs(oldName, newNameStr));`
	`361`	`+ _queueNameChangedAfterRecoveryWrapper.Invoke(this, new QueueNameChangedAfterRecoveryEventArgs(oldName, newName));`
`362`	`362`	`}`
`363`	`363`	`finally`
`364`	`364`	`{`
Original file line number	Diff line number	Diff line change
`@@ -73,16 +73,20 @@ public RecordedQueue(QueueName newName, in RecordedQueue old)`
`73`	`73`	`_arguments = old._arguments;`
`74`	`74`	`}`
`75`	`75`
`76`		`- public Task<QueueDeclareOk> RecoverAsync(IChannel channel, CancellationToken cancellationToken)`
	`76`	`+ public async Task<QueueName> RecoverAsync(IChannel channel, CancellationToken cancellationToken)`
`77`	`77`	`{`
`78`	`78`	`QueueName queueName = _name;`
`79`	`79`	`if (_name.IsEmpty)`
`80`	`80`	`{`
`81`	`81`	`queueName = QueueName.Empty;`
`82`	`82`	`}`
`83`		`- return channel.QueueDeclareAsync(queue: queueName, passive: false,`
	`83`	`+`
	`84`	`+ QueueDeclareOk queueDeclareResult = await channel.QueueDeclareAsync(queue: queueName, passive: false,`
`84`	`85`	`durable: _durable, exclusive: _exclusive, autoDelete: AutoDelete, arguments: _arguments,`
`85`		`- cancellationToken: cancellationToken);`
	`86`	`+ cancellationToken: cancellationToken)`
	`87`	`+ .ConfigureAwait(false);`
	`88`	`+`
	`89`	`+ return new QueueName(queueDeclareResult.QueueName);`
`86`	`90`	`}`
`87`	`91`
`88`	`92`	`public override string ToString()`