Rename several methods in AsyncEventingBasicConsumer to use Async suffix.

lukebakken · lukebakken · commit e6e8b5c7ad76 · 2024-09-19T06:00:10.000-07:00
diff --git a/projects/Benchmarks/ConsumerDispatching/AsyncBasicConsumerFake.cs b/projects/Benchmarks/ConsumerDispatching/AsyncBasicConsumerFake.cs
@@ -37,8 +37,6 @@ public Task HandleBasicDeliverAsync(string consumerTag, ulong deliveryTag, bool
 
         public Task HandleChannelShutdownAsync(object channel, ShutdownEventArgs reason) => Task.CompletedTask;
 
-        public Task OnCancelAsync(string[] consumerTags, CancellationToken cancellationToken = default) => Task.CompletedTask;
-
         public IChannel Channel { get; }
     }
 }
diff --git a/projects/RabbitMQ.Client/PublicAPI.Shipped.txt b/projects/RabbitMQ.Client/PublicAPI.Shipped.txt
@@ -246,10 +246,6 @@ RabbitMQ.Client.EndpointResolverExtensions
 RabbitMQ.Client.Events.AsyncEventHandler<TEvent>
 RabbitMQ.Client.Events.AsyncEventingBasicConsumer
 RabbitMQ.Client.Events.AsyncEventingBasicConsumer.AsyncEventingBasicConsumer(RabbitMQ.Client.IChannel channel) -> void
-RabbitMQ.Client.Events.AsyncEventingBasicConsumer.Received -> RabbitMQ.Client.Events.AsyncEventHandler<RabbitMQ.Client.Events.BasicDeliverEventArgs>
-RabbitMQ.Client.Events.AsyncEventingBasicConsumer.Registered -> RabbitMQ.Client.Events.AsyncEventHandler<RabbitMQ.Client.Events.ConsumerEventArgs>
-RabbitMQ.Client.Events.AsyncEventingBasicConsumer.Shutdown -> RabbitMQ.Client.Events.AsyncEventHandler<RabbitMQ.Client.ShutdownEventArgs>
-RabbitMQ.Client.Events.AsyncEventingBasicConsumer.Unregistered -> RabbitMQ.Client.Events.AsyncEventHandler<RabbitMQ.Client.Events.ConsumerEventArgs>
 RabbitMQ.Client.Events.BaseExceptionEventArgs
 RabbitMQ.Client.Events.BasicAckEventArgs
 RabbitMQ.Client.Events.BasicDeliverEventArgs
@@ -900,3 +896,7 @@ virtual RabbitMQ.Client.AsyncDefaultBasicConsumer.HandleBasicCancelOkAsync(strin
 virtual RabbitMQ.Client.AsyncDefaultBasicConsumer.HandleBasicConsumeOkAsync(string! consumerTag, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!
 virtual RabbitMQ.Client.AsyncDefaultBasicConsumer.HandleBasicDeliverAsync(string! consumerTag, ulong deliveryTag, bool redelivered, string! exchange, string! routingKey, RabbitMQ.Client.IReadOnlyBasicProperties! properties, System.ReadOnlyMemory<byte> body, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!
 virtual RabbitMQ.Client.AsyncDefaultBasicConsumer.OnCancelAsync(string![]! consumerTags, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!
+RabbitMQ.Client.Events.AsyncEventingBasicConsumer.ShutdownAsync -> RabbitMQ.Client.Events.AsyncEventHandler<RabbitMQ.Client.ShutdownEventArgs!>!
+RabbitMQ.Client.Events.AsyncEventingBasicConsumer.UnregisteredAsync -> RabbitMQ.Client.Events.AsyncEventHandler<RabbitMQ.Client.Events.ConsumerEventArgs!>!
+RabbitMQ.Client.Events.AsyncEventingBasicConsumer.RegisteredAsync -> RabbitMQ.Client.Events.AsyncEventHandler<RabbitMQ.Client.Events.ConsumerEventArgs!>!
+RabbitMQ.Client.Events.AsyncEventingBasicConsumer.ReceivedAsync -> RabbitMQ.Client.Events.AsyncEventHandler<RabbitMQ.Client.Events.BasicDeliverEventArgs!>!
diff --git a/projects/RabbitMQ.Client/client/events/AsyncEventingBasicConsumer.cs b/projects/RabbitMQ.Client/client/events/AsyncEventingBasicConsumer.cs
@@ -20,45 +20,45 @@ public AsyncEventingBasicConsumer(IChannel channel) : base(channel)
         /// Accessing the body at a later point is unsafe as its memory can
         /// be already released.
         /// </remarks>
-        public event AsyncEventHandler<BasicDeliverEventArgs> Received
+        public event AsyncEventHandler<BasicDeliverEventArgs> ReceivedAsync
         {
-            add => _receivedWrapper.AddHandler(value);
-            remove => _receivedWrapper.RemoveHandler(value);
+            add => _receivedAsyncWrapper.AddHandler(value);
+            remove => _receivedAsyncWrapper.RemoveHandler(value);
         }
-        private AsyncEventingWrapper<BasicDeliverEventArgs> _receivedWrapper;
+        private AsyncEventingWrapper<BasicDeliverEventArgs> _receivedAsyncWrapper;
 
         ///<summary>Fires when the server confirms successful consumer registration.</summary>
-        public event AsyncEventHandler<ConsumerEventArgs> Registered
+        public event AsyncEventHandler<ConsumerEventArgs> RegisteredAsync
         {
-            add => _registeredWrapper.AddHandler(value);
-            remove => _registeredWrapper.RemoveHandler(value);
+            add => _registeredAsyncWrapper.AddHandler(value);
+            remove => _registeredAsyncWrapper.RemoveHandler(value);
         }
-        private AsyncEventingWrapper<ConsumerEventArgs> _registeredWrapper;
+        private AsyncEventingWrapper<ConsumerEventArgs> _registeredAsyncWrapper;
 
         ///<summary>Fires on channel shutdown, both client and server initiated.</summary>
-        public event AsyncEventHandler<ShutdownEventArgs> Shutdown
+        public event AsyncEventHandler<ShutdownEventArgs> ShutdownAsync
         {
-            add => _shutdownWrapper.AddHandler(value);
-            remove => _shutdownWrapper.RemoveHandler(value);
+            add => _shutdownAsyncWrapper.AddHandler(value);
+            remove => _shutdownAsyncWrapper.RemoveHandler(value);
         }
-        private AsyncEventingWrapper<ShutdownEventArgs> _shutdownWrapper;
+        private AsyncEventingWrapper<ShutdownEventArgs> _shutdownAsyncWrapper;
 
         ///<summary>Fires when the server confirms successful consumer cancellation.</summary>
-        public event AsyncEventHandler<ConsumerEventArgs> Unregistered
+        public event AsyncEventHandler<ConsumerEventArgs> UnregisteredAsync
         {
-            add => _unregisteredWrapper.AddHandler(value);
-            remove => _unregisteredWrapper.RemoveHandler(value);
+            add => _unregisteredAsyncWrapper.AddHandler(value);
+            remove => _unregisteredAsyncWrapper.RemoveHandler(value);
         }
-        private AsyncEventingWrapper<ConsumerEventArgs> _unregisteredWrapper;
+        private AsyncEventingWrapper<ConsumerEventArgs> _unregisteredAsyncWrapper;
 
         ///<summary>Fires when the server confirms successful consumer cancellation.</summary>
         protected override async Task OnCancelAsync(string[] consumerTags, CancellationToken cancellationToken = default)
         {
             await base.OnCancelAsync(consumerTags, cancellationToken)
                 .ConfigureAwait(false);
-            if (!_unregisteredWrapper.IsEmpty)
+            if (!_unregisteredAsyncWrapper.IsEmpty)
             {
-                await _unregisteredWrapper.InvokeAsync(this, new ConsumerEventArgs(consumerTags, cancellationToken))
+                await _unregisteredAsyncWrapper.InvokeAsync(this, new ConsumerEventArgs(consumerTags, cancellationToken))
                     .ConfigureAwait(false);
             }
         }
@@ -68,9 +68,9 @@ public override async Task HandleBasicConsumeOkAsync(string consumerTag, Cancell
         {
             await base.HandleBasicConsumeOkAsync(consumerTag, cancellationToken)
                 .ConfigureAwait(false);
-            if (!_registeredWrapper.IsEmpty)
+            if (!_registeredAsyncWrapper.IsEmpty)
             {
-                await _registeredWrapper.InvokeAsync(this, new ConsumerEventArgs(new[] { consumerTag }, cancellationToken))
+                await _registeredAsyncWrapper.InvokeAsync(this, new ConsumerEventArgs(new[] { consumerTag }, cancellationToken))
                     .ConfigureAwait(false);
             }
         }
@@ -82,17 +82,17 @@ public override Task HandleBasicDeliverAsync(string consumerTag, ulong deliveryT
             var deliverEventArgs = new BasicDeliverEventArgs(consumerTag, deliveryTag, redelivered, exchange, routingKey, properties, body, cancellationToken);
 
             // No need to call base, it's empty.
-            return _receivedWrapper.InvokeAsync(this, deliverEventArgs);
+            return _receivedAsyncWrapper.InvokeAsync(this, deliverEventArgs);
         }
 
         ///<summary>Fires the Shutdown event.</summary>
         public override async Task HandleChannelShutdownAsync(object channel, ShutdownEventArgs reason)
         {
             await base.HandleChannelShutdownAsync(channel, reason)
                 .ConfigureAwait(false);
-            if (!_shutdownWrapper.IsEmpty)
+            if (!_shutdownAsyncWrapper.IsEmpty)
             {
-                await _shutdownWrapper.InvokeAsync(this, reason)
+                await _shutdownAsyncWrapper.InvokeAsync(this, reason)
                     .ConfigureAwait(false);
             }
         }
diff --git a/projects/RabbitMQ.Client/client/events/BasicDeliverEventArgs.cs b/projects/RabbitMQ.Client/client/events/BasicDeliverEventArgs.cs
@@ -67,7 +67,7 @@ public BasicDeliverEventArgs(string consumerTag,
         /// </para>
         /// <para>
         ///   NOTE: Using this memory outside of
-        ///   <c><seealso cref="AsyncEventingBasicConsumer.Received"/></c>
+        ///   <c><seealso cref="AsyncEventingBasicConsumer.ReceivedAsync"/></c>
         ///   requires that it be copied!
         ///   <example>
         ///   This shows how to copy the data for use:
diff --git a/projects/Test/Applications/MassPublish/Program.cs b/projects/Test/Applications/MassPublish/Program.cs
@@ -81,7 +81,7 @@ await consumeChannel.QueueDeclareAsync(queue: QueueName,
                 passive: false, durable: false, exclusive: false, autoDelete: false, arguments: null);
 
             var asyncListener = new AsyncEventingBasicConsumer(consumeChannel);
-            asyncListener.Received += AsyncListener_Received;
+            asyncListener.ReceivedAsync += AsyncListener_Received;
 
             await consumeChannel.QueueBindAsync(queue: QueueName, exchange: ExchangeName, routingKey: RoutingKey, arguments: null);
 
diff --git a/projects/Test/Integration/ConnectionRecovery/TestConnectionRecovery.cs b/projects/Test/Integration/ConnectionRecovery/TestConnectionRecovery.cs
@@ -93,7 +93,7 @@ await _channel.ExchangeDeclareAsync(exchange: exchangeName,
             await _channel.QueueBindAsync(queue: queueName, exchange: exchangeName, routingKey: routingKey);
 
             var consumer = new AsyncEventingBasicConsumer(_channel);
-            consumer.Received += MessageReceived;
+            consumer.ReceivedAsync += MessageReceived;
             await _channel.BasicConsumeAsync(queueName, true, consumer);
 
             using (IChannel pubCh = await _conn.CreateChannelAsync())
diff --git a/projects/Test/Integration/TestAsyncConsumer.cs b/projects/Test/Integration/TestAsyncConsumer.cs
@@ -105,7 +105,7 @@ public async Task TestBasicRoundtripConcurrent()
                     return Task.CompletedTask;
                 };
 
-                consumer.Received += (o, a) =>
+                consumer.ReceivedAsync += (o, a) =>
                 {
                     if (ByteArraysEqual(a.Body.Span, body1))
                     {
@@ -274,7 +274,7 @@ public async Task TestBasicRoundtripConcurrentManyMessages()
                                     };
 
                                     var consumer = new AsyncEventingBasicConsumer(consumeChannel);
-                                    consumer.Received += (o, a) =>
+                                    consumer.ReceivedAsync += (o, a) =>
                                     {
                                         if (ByteArraysEqual(a.Body.ToArray(), body1))
                                         {
@@ -370,7 +370,7 @@ public async Task TestBasicRejectAsync()
                 };
 
                 var consumer = new AsyncEventingBasicConsumer(_channel);
-                consumer.Received += async (object sender, BasicDeliverEventArgs args) =>
+                consumer.ReceivedAsync += async (object sender, BasicDeliverEventArgs args) =>
                 {
                     var c = sender as AsyncEventingBasicConsumer;
                     Assert.Same(c, consumer);
@@ -470,7 +470,7 @@ public async Task TestBasicAckAsync()
             await _channel.ConfirmSelectAsync();
 
             var consumer = new AsyncEventingBasicConsumer(_channel);
-            consumer.Received += async (object sender, BasicDeliverEventArgs args) =>
+            consumer.ReceivedAsync += async (object sender, BasicDeliverEventArgs args) =>
             {
                 var c = sender as AsyncEventingBasicConsumer;
                 Assert.NotNull(c);
@@ -534,7 +534,7 @@ public async Task TestBasicNackAsync()
             };
 
             var consumer = new AsyncEventingBasicConsumer(_channel);
-            consumer.Received += async (object sender, BasicDeliverEventArgs args) =>
+            consumer.ReceivedAsync += async (object sender, BasicDeliverEventArgs args) =>
             {
                 var c = sender as AsyncEventingBasicConsumer;
                 Assert.NotNull(c);
@@ -651,7 +651,7 @@ public async Task TestCreateChannelWithinAsyncConsumerCallback_GH650()
             await _channel.QueueBindAsync(queue2Name, exchangeName, queue2Name);
 
             var consumer1 = new AsyncEventingBasicConsumer(_channel);
-            consumer1.Received += async (sender, args) =>
+            consumer1.ReceivedAsync += async (sender, args) =>
             {
                 using (IChannel innerChannel = await _conn.CreateChannelAsync())
                 {
@@ -666,7 +666,7 @@ await innerChannel.BasicPublishAsync(exchangeName, queue2Name,
             await _channel.BasicConsumeAsync(queue1Name, autoAck: true, consumer1);
 
             var consumer2 = new AsyncEventingBasicConsumer(_channel);
-            consumer2.Received += async (sender, args) =>
+            consumer2.ReceivedAsync += async (sender, args) =>
             {
                 tcs.TrySetResult(true);
                 await Task.Yield();
@@ -691,7 +691,7 @@ public async Task TestCloseWithinEventHandler_GH1567()
             string queueName = q.QueueName;
 
             var consumer = new AsyncEventingBasicConsumer(_channel);
-            consumer.Received += async (_, eventArgs) =>
+            consumer.ReceivedAsync += async (_, eventArgs) =>
             {
                 await _channel.BasicCancelAsync(eventArgs.ConsumerTag);
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
diff --git a/projects/Test/Integration/TestAsyncConsumerCancelNotify.cs b/projects/Test/Integration/TestAsyncConsumerCancelNotify.cs
@@ -74,7 +74,7 @@ public async Task TestCorrectConsumerTag()
             string consumerTag2 = await _channel.BasicConsumeAsync(q2, true, consumer);
 
             string notifiedConsumerTag = null;
-            consumer.Unregistered += (sender, args) =>
+            consumer.UnregisteredAsync += (sender, args) =>
             {
                 notifiedConsumerTag = args.ConsumerTags.First();
                 _tcs.TrySetResult(true);
@@ -111,7 +111,7 @@ public CancelNotificationConsumer(IChannel channel, TestAsyncConsumerCancelNotif
                 _eventMode = eventMode;
                 if (eventMode)
                 {
-                    Unregistered += CancelledAsync;
+                    UnregisteredAsync += CancelledAsync;
                 }
             }
 
diff --git a/projects/Test/Integration/TestAsyncConsumerOperationDispatch.cs b/projects/Test/Integration/TestAsyncConsumerOperationDispatch.cs
@@ -169,7 +169,7 @@ public async Task TestChannelShutdownDoesNotShutDownDispatcher()
             var tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
             await ch1.BasicConsumeAsync(q1, true, new AsyncEventingBasicConsumer(ch1));
             var c2 = new AsyncEventingBasicConsumer(ch2);
-            c2.Received += (object sender, BasicDeliverEventArgs e) =>
+            c2.ReceivedAsync += (object sender, BasicDeliverEventArgs e) =>
             {
                 tcs.SetResult(true);
                 return Task.CompletedTask;
diff --git a/projects/Test/Integration/TestAsyncEventingBasicConsumer.cs b/projects/Test/Integration/TestAsyncEventingBasicConsumer.cs
@@ -101,7 +101,7 @@ public async Task TestAsyncEventingBasicConsumer_GH1038()
 
             //async subscriber
             var consumer = new AsyncEventingBasicConsumer(_channel);
-            consumer.Received += AsyncConsumerOnReceived;
+            consumer.ReceivedAsync += AsyncConsumerOnReceived;
             await _channel.BasicConsumeAsync(queueName, false, consumer);
 
             //publisher
diff --git a/projects/Test/Integration/TestBasicPublish.cs b/projects/Test/Integration/TestBasicPublish.cs
@@ -68,7 +68,7 @@ public async Task TestBasicRoundtripArray()
             var consumer = new AsyncEventingBasicConsumer(_channel);
             using (var consumerReceivedSemaphore = new SemaphoreSlim(0, 1))
             {
-                consumer.Received += (o, a) =>
+                consumer.ReceivedAsync += (o, a) =>
                 {
                     consumeBody = a.Body.ToArray();
                     consumerReceivedSemaphore.Release();
@@ -98,7 +98,7 @@ public async Task TestBasicRoundtripCachedString()
             var consumer = new AsyncEventingBasicConsumer(_channel);
             using (var consumerReceivedSemaphore = new SemaphoreSlim(0, 1))
             {
-                consumer.Received += (o, a) =>
+                consumer.ReceivedAsync += (o, a) =>
                 {
                     consumeBody = a.Body.ToArray();
                     consumerReceivedSemaphore.Release();
@@ -127,7 +127,7 @@ public async Task TestBasicRoundtripReadOnlyMemory()
             var consumer = new AsyncEventingBasicConsumer(_channel);
             using (var consumerReceivedSemaphore = new SemaphoreSlim(0, 1))
             {
-                consumer.Received += (o, a) =>
+                consumer.ReceivedAsync += (o, a) =>
                 {
                     consumeBody = a.Body.ToArray();
                     consumerReceivedSemaphore.Release();
@@ -156,7 +156,7 @@ public async Task CanNotModifyPayloadAfterPublish()
             using (var consumerReceivedSemaphore = new SemaphoreSlim(0, 1))
             {
                 bool modified = true;
-                consumer.Received += (o, a) =>
+                consumer.ReceivedAsync += (o, a) =>
                 {
                     if (a.Body.Span.IndexOf((byte)1) < 0)
                     {
@@ -229,25 +229,25 @@ public async Task TestMaxInboundMessageBodySize()
 
                     var consumer = new AsyncEventingBasicConsumer(channel);
 
-                    consumer.Shutdown += (o, a) =>
+                    consumer.ShutdownAsync += (o, a) =>
                     {
                         tcs.SetResult(true);
                         return Task.CompletedTask;
                     };
 
-                    consumer.Registered += (o, a) =>
+                    consumer.RegisteredAsync += (o, a) =>
                     {
                         sawConsumerRegistered = true;
                         return Task.CompletedTask;
                     };
 
-                    consumer.Unregistered += (o, a) =>
+                    consumer.UnregisteredAsync += (o, a) =>
                     {
                         sawConsumerUnregistered = true;
                         return Task.CompletedTask;
                     };
 
-                    consumer.Received += (o, a) =>
+                    consumer.ReceivedAsync += (o, a) =>
                     {
                         Interlocked.Increment(ref count);
                         return Task.CompletedTask;
@@ -312,7 +312,7 @@ public async Task TestPropertiesRoundtrip_Headers()
             using (var consumerReceivedSemaphore = new SemaphoreSlim(0, 1))
             {
                 string response = null;
-                consumer.Received += (o, a) =>
+                consumer.ReceivedAsync += (o, a) =>
                 {
                     response = _encoding.GetString(a.BasicProperties.Headers["Hello"] as byte[]);
                     consumeBody = a.Body.ToArray();
diff --git a/projects/Test/Integration/TestConcurrentAccessWithSharedChannel.cs b/projects/Test/Integration/TestConcurrentAccessWithSharedChannel.cs
@@ -82,7 +82,7 @@ await TestConcurrentOperationsAsync(async () =>
 
                 var consumer = new AsyncEventingBasicConsumer(_channel);
 
-                consumer.Received += async (object sender, BasicDeliverEventArgs ea) =>
+                consumer.ReceivedAsync += async (object sender, BasicDeliverEventArgs ea) =>
                 {
                     try
                     {
diff --git a/projects/Test/Integration/TestConnectionRecoveryWithoutSetup.cs b/projects/Test/Integration/TestConnectionRecoveryWithoutSetup.cs
diff --git a/projects/Test/Integration/TestConnectionTopologyRecovery.cs b/projects/Test/Integration/TestConnectionTopologyRecovery.cs
diff --git a/projects/Test/Integration/TestFloodPublishing.cs b/projects/Test/Integration/TestFloodPublishing.cs
diff --git a/projects/Test/OAuth2/TestOAuth2.cs b/projects/Test/OAuth2/TestOAuth2.cs
diff --git a/projects/Test/SequentialIntegration/TestActivitySource.cs b/projects/Test/SequentialIntegration/TestActivitySource.cs
diff --git a/projects/Test/SequentialIntegration/TestOpenTelemetry.cs b/projects/Test/SequentialIntegration/TestOpenTelemetry.cs

Original file line number	Diff line number	Diff line change
`@@ -37,8 +37,6 @@ public Task HandleBasicDeliverAsync(string consumerTag, ulong deliveryTag, bool`
`37`	`37`
`38`	`38`	`public Task HandleChannelShutdownAsync(object channel, ShutdownEventArgs reason) => Task.CompletedTask;`
`39`	`39`
`40`		`- public Task OnCancelAsync(string[] consumerTags, CancellationToken cancellationToken = default) => Task.CompletedTask;`
`41`		`-`
`42`	`40`	`public IChannel Channel { get; }`
`43`	`41`	`}`
`44`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,45 +20,45 @@ public AsyncEventingBasicConsumer(IChannel channel) : base(channel)`
`20`	`20`	`/// Accessing the body at a later point is unsafe as its memory can`
`21`	`21`	`/// be already released.`
`22`	`22`	`/// </remarks>`
`23`		`- public event AsyncEventHandler<BasicDeliverEventArgs> Received`
	`23`	`+ public event AsyncEventHandler<BasicDeliverEventArgs> ReceivedAsync`
`24`	`24`	`{`
`25`		`- add => _receivedWrapper.AddHandler(value);`
`26`		`- remove => _receivedWrapper.RemoveHandler(value);`
	`25`	`+ add => _receivedAsyncWrapper.AddHandler(value);`
	`26`	`+ remove => _receivedAsyncWrapper.RemoveHandler(value);`
`27`	`27`	`}`
`28`		`- private AsyncEventingWrapper<BasicDeliverEventArgs> _receivedWrapper;`
	`28`	`+ private AsyncEventingWrapper<BasicDeliverEventArgs> _receivedAsyncWrapper;`
`29`	`29`
`30`	`30`	`///<summary>Fires when the server confirms successful consumer registration.</summary>`
`31`		`- public event AsyncEventHandler<ConsumerEventArgs> Registered`
	`31`	`+ public event AsyncEventHandler<ConsumerEventArgs> RegisteredAsync`
`32`	`32`	`{`
`33`		`- add => _registeredWrapper.AddHandler(value);`
`34`		`- remove => _registeredWrapper.RemoveHandler(value);`
	`33`	`+ add => _registeredAsyncWrapper.AddHandler(value);`
	`34`	`+ remove => _registeredAsyncWrapper.RemoveHandler(value);`
`35`	`35`	`}`
`36`		`- private AsyncEventingWrapper<ConsumerEventArgs> _registeredWrapper;`
	`36`	`+ private AsyncEventingWrapper<ConsumerEventArgs> _registeredAsyncWrapper;`
`37`	`37`
`38`	`38`	`///<summary>Fires on channel shutdown, both client and server initiated.</summary>`
`39`		`- public event AsyncEventHandler<ShutdownEventArgs> Shutdown`
	`39`	`+ public event AsyncEventHandler<ShutdownEventArgs> ShutdownAsync`
`40`	`40`	`{`
`41`		`- add => _shutdownWrapper.AddHandler(value);`
`42`		`- remove => _shutdownWrapper.RemoveHandler(value);`
	`41`	`+ add => _shutdownAsyncWrapper.AddHandler(value);`
	`42`	`+ remove => _shutdownAsyncWrapper.RemoveHandler(value);`
`43`	`43`	`}`
`44`		`- private AsyncEventingWrapper<ShutdownEventArgs> _shutdownWrapper;`
	`44`	`+ private AsyncEventingWrapper<ShutdownEventArgs> _shutdownAsyncWrapper;`
`45`	`45`
`46`	`46`	`///<summary>Fires when the server confirms successful consumer cancellation.</summary>`
`47`		`- public event AsyncEventHandler<ConsumerEventArgs> Unregistered`
	`47`	`+ public event AsyncEventHandler<ConsumerEventArgs> UnregisteredAsync`
`48`	`48`	`{`
`49`		`- add => _unregisteredWrapper.AddHandler(value);`
`50`		`- remove => _unregisteredWrapper.RemoveHandler(value);`
	`49`	`+ add => _unregisteredAsyncWrapper.AddHandler(value);`
	`50`	`+ remove => _unregisteredAsyncWrapper.RemoveHandler(value);`
`51`	`51`	`}`
`52`		`- private AsyncEventingWrapper<ConsumerEventArgs> _unregisteredWrapper;`
	`52`	`+ private AsyncEventingWrapper<ConsumerEventArgs> _unregisteredAsyncWrapper;`
`53`	`53`
`54`	`54`	`///<summary>Fires when the server confirms successful consumer cancellation.</summary>`
`55`	`55`	`protected override async Task OnCancelAsync(string[] consumerTags, CancellationToken cancellationToken = default)`
`56`	`56`	`{`
`57`	`57`	`await base.OnCancelAsync(consumerTags, cancellationToken)`
`58`	`58`	`.ConfigureAwait(false);`
`59`		`- if (!_unregisteredWrapper.IsEmpty)`
	`59`	`+ if (!_unregisteredAsyncWrapper.IsEmpty)`
`60`	`60`	`{`
`61`		`- await _unregisteredWrapper.InvokeAsync(this, new ConsumerEventArgs(consumerTags, cancellationToken))`
	`61`	`+ await _unregisteredAsyncWrapper.InvokeAsync(this, new ConsumerEventArgs(consumerTags, cancellationToken))`
`62`	`62`	`.ConfigureAwait(false);`
`63`	`63`	`}`
`64`	`64`	`}`
`@@ -68,9 +68,9 @@ public override async Task HandleBasicConsumeOkAsync(string consumerTag, Cancell`
`68`	`68`	`{`
`69`	`69`	`await base.HandleBasicConsumeOkAsync(consumerTag, cancellationToken)`
`70`	`70`	`.ConfigureAwait(false);`
`71`		`- if (!_registeredWrapper.IsEmpty)`
	`71`	`+ if (!_registeredAsyncWrapper.IsEmpty)`
`72`	`72`	`{`
`73`		`- await _registeredWrapper.InvokeAsync(this, new ConsumerEventArgs(new[] { consumerTag }, cancellationToken))`
	`73`	`+ await _registeredAsyncWrapper.InvokeAsync(this, new ConsumerEventArgs(new[] { consumerTag }, cancellationToken))`
`74`	`74`	`.ConfigureAwait(false);`
`75`	`75`	`}`
`76`	`76`	`}`
`@@ -82,17 +82,17 @@ public override Task HandleBasicDeliverAsync(string consumerTag, ulong deliveryT`
`82`	`82`	`var deliverEventArgs = new BasicDeliverEventArgs(consumerTag, deliveryTag, redelivered, exchange, routingKey, properties, body, cancellationToken);`
`83`	`83`
`84`	`84`	`// No need to call base, it's empty.`
`85`		`- return _receivedWrapper.InvokeAsync(this, deliverEventArgs);`
	`85`	`+ return _receivedAsyncWrapper.InvokeAsync(this, deliverEventArgs);`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`///<summary>Fires the Shutdown event.</summary>`
`89`	`89`	`public override async Task HandleChannelShutdownAsync(object channel, ShutdownEventArgs reason)`
`90`	`90`	`{`
`91`	`91`	`await base.HandleChannelShutdownAsync(channel, reason)`
`92`	`92`	`.ConfigureAwait(false);`
`93`		`- if (!_shutdownWrapper.IsEmpty)`
	`93`	`+ if (!_shutdownAsyncWrapper.IsEmpty)`
`94`	`94`	`{`
`95`		`- await _shutdownWrapper.InvokeAsync(this, reason)`
	`95`	`+ await _shutdownAsyncWrapper.InvokeAsync(this, reason)`
`96`	`96`	`.ConfigureAwait(false);`
`97`	`97`	`}`
`98`	`98`	`}`
Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ public async Task TestBasicRoundtripConcurrent()`
`105`	`105`	`return Task.CompletedTask;`
`106`	`106`	`};`
`107`	`107`
`108`		`- consumer.Received += (o, a) =>`
	`108`	`+ consumer.ReceivedAsync += (o, a) =>`
`109`	`109`	`{`
`110`	`110`	`if (ByteArraysEqual(a.Body.Span, body1))`
`111`	`111`	`{`
`@@ -274,7 +274,7 @@ public async Task TestBasicRoundtripConcurrentManyMessages()`
`274`	`274`	`};`
`275`	`275`
`276`	`276`	`var consumer = new AsyncEventingBasicConsumer(consumeChannel);`
`277`		`- consumer.Received += (o, a) =>`
	`277`	`+ consumer.ReceivedAsync += (o, a) =>`
`278`	`278`	`{`
`279`	`279`	`if (ByteArraysEqual(a.Body.ToArray(), body1))`
`280`	`280`	`{`
`@@ -370,7 +370,7 @@ public async Task TestBasicRejectAsync()`
`370`	`370`	`};`
`371`	`371`
`372`	`372`	`var consumer = new AsyncEventingBasicConsumer(_channel);`
`373`		`- consumer.Received += async (object sender, BasicDeliverEventArgs args) =>`
	`373`	`+ consumer.ReceivedAsync += async (object sender, BasicDeliverEventArgs args) =>`
`374`	`374`	`{`
`375`	`375`	`var c = sender as AsyncEventingBasicConsumer;`
`376`	`376`	`Assert.Same(c, consumer);`
`@@ -470,7 +470,7 @@ public async Task TestBasicAckAsync()`
`470`	`470`	`await _channel.ConfirmSelectAsync();`
`471`	`471`
`472`	`472`	`var consumer = new AsyncEventingBasicConsumer(_channel);`
`473`		`- consumer.Received += async (object sender, BasicDeliverEventArgs args) =>`
	`473`	`+ consumer.ReceivedAsync += async (object sender, BasicDeliverEventArgs args) =>`
`474`	`474`	`{`
`475`	`475`	`var c = sender as AsyncEventingBasicConsumer;`
`476`	`476`	`Assert.NotNull(c);`
`@@ -534,7 +534,7 @@ public async Task TestBasicNackAsync()`
`534`	`534`	`};`
`535`	`535`
`536`	`536`	`var consumer = new AsyncEventingBasicConsumer(_channel);`
`537`		`- consumer.Received += async (object sender, BasicDeliverEventArgs args) =>`
	`537`	`+ consumer.ReceivedAsync += async (object sender, BasicDeliverEventArgs args) =>`
`538`	`538`	`{`
`539`	`539`	`var c = sender as AsyncEventingBasicConsumer;`
`540`	`540`	`Assert.NotNull(c);`
`@@ -651,7 +651,7 @@ public async Task TestCreateChannelWithinAsyncConsumerCallback_GH650()`
`651`	`651`	`await _channel.QueueBindAsync(queue2Name, exchangeName, queue2Name);`
`652`	`652`
`653`	`653`	`var consumer1 = new AsyncEventingBasicConsumer(_channel);`
`654`		`- consumer1.Received += async (sender, args) =>`
	`654`	`+ consumer1.ReceivedAsync += async (sender, args) =>`
`655`	`655`	`{`
`656`	`656`	`using (IChannel innerChannel = await _conn.CreateChannelAsync())`
`657`	`657`	`{`
`@@ -666,7 +666,7 @@ await innerChannel.BasicPublishAsync(exchangeName, queue2Name,`
`666`	`666`	`await _channel.BasicConsumeAsync(queue1Name, autoAck: true, consumer1);`
`667`	`667`
`668`	`668`	`var consumer2 = new AsyncEventingBasicConsumer(_channel);`
`669`		`- consumer2.Received += async (sender, args) =>`
	`669`	`+ consumer2.ReceivedAsync += async (sender, args) =>`
`670`	`670`	`{`
`671`	`671`	`tcs.TrySetResult(true);`
`672`	`672`	`await Task.Yield();`
`@@ -691,7 +691,7 @@ public async Task TestCloseWithinEventHandler_GH1567()`
`691`	`691`	`string queueName = q.QueueName;`
`692`	`692`
`693`	`693`	`var consumer = new AsyncEventingBasicConsumer(_channel);`
`694`		`- consumer.Received += async (_, eventArgs) =>`
	`694`	`+ consumer.ReceivedAsync += async (_, eventArgs) =>`
`695`	`695`	`{`
`696`	`696`	`await _channel.BasicCancelAsync(eventArgs.ConsumerTag);`
`697`	`697`	`#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ public async Task TestCorrectConsumerTag()`
`74`	`74`	`string consumerTag2 = await _channel.BasicConsumeAsync(q2, true, consumer);`
`75`	`75`
`76`	`76`	`string notifiedConsumerTag = null;`
`77`		`- consumer.Unregistered += (sender, args) =>`
	`77`	`+ consumer.UnregisteredAsync += (sender, args) =>`
`78`	`78`	`{`
`79`	`79`	`notifiedConsumerTag = args.ConsumerTags.First();`
`80`	`80`	`_tcs.TrySetResult(true);`
`@@ -111,7 +111,7 @@ public CancelNotificationConsumer(IChannel channel, TestAsyncConsumerCancelNotif`
`111`	`111`	`_eventMode = eventMode;`
`112`	`112`	`if (eventMode)`
`113`	`113`	`{`
`114`		`- Unregistered += CancelledAsync;`
	`114`	`+ UnregisteredAsync += CancelledAsync;`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`
Original file line number	Diff line number	Diff line change
`@@ -169,7 +169,7 @@ public async Task TestChannelShutdownDoesNotShutDownDispatcher()`
`169`	`169`	`var tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);`
`170`	`170`	`await ch1.BasicConsumeAsync(q1, true, new AsyncEventingBasicConsumer(ch1));`
`171`	`171`	`var c2 = new AsyncEventingBasicConsumer(ch2);`
`172`		`- c2.Received += (object sender, BasicDeliverEventArgs e) =>`
	`172`	`+ c2.ReceivedAsync += (object sender, BasicDeliverEventArgs e) =>`
`173`	`173`	`{`
`174`	`174`	`tcs.SetResult(true);`
`175`	`175`	`return Task.CompletedTask;`