Revert "Make event handlers for basic.ack, basic.nack and basic.return async."

lukebakken · lukebakken · commit c22949f65f0e · 2024-09-16T18:55:11.000-07:00
This reverts commit ccf0764.
diff --git a/projects/RabbitMQ.Client/PublicAPI.Shipped.txt b/projects/RabbitMQ.Client/PublicAPI.Shipped.txt
@@ -426,7 +426,10 @@ RabbitMQ.Client.IBasicProperties.UserId.get -> string
 RabbitMQ.Client.IBasicProperties.UserId.set -> void
 RabbitMQ.Client.IChannel
 RabbitMQ.Client.IChannel.BasicAckAsync(ulong deliveryTag, bool multiple, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask
+RabbitMQ.Client.IChannel.BasicAcks -> System.EventHandler<RabbitMQ.Client.Events.BasicAckEventArgs>
 RabbitMQ.Client.IChannel.BasicNackAsync(ulong deliveryTag, bool multiple, bool requeue, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask
+RabbitMQ.Client.IChannel.BasicNacks -> System.EventHandler<RabbitMQ.Client.Events.BasicNackEventArgs>
+RabbitMQ.Client.IChannel.BasicReturn -> System.EventHandler<RabbitMQ.Client.Events.BasicReturnEventArgs>
 RabbitMQ.Client.IChannel.CallbackException -> System.EventHandler<RabbitMQ.Client.Events.CallbackExceptionEventArgs>
 RabbitMQ.Client.IChannel.ChannelNumber.get -> int
 RabbitMQ.Client.IChannel.ChannelShutdown -> System.EventHandler<RabbitMQ.Client.ShutdownEventArgs>
@@ -892,7 +895,3 @@ RabbitMQ.Client.IChannel.ConfirmSelectAsync(bool trackConfirmations = true, Syst
 const RabbitMQ.Client.Constants.DefaultConsumerDispatchConcurrency = 1 -> ushort
 readonly RabbitMQ.Client.ConnectionConfig.ConsumerDispatchConcurrency -> ushort
 RabbitMQ.Client.IConnection.CreateChannelAsync(ushort? consumerDispatchConcurrency = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<RabbitMQ.Client.IChannel!>!
-RabbitMQ.Client.IChannel.BasicAcksAsync -> RabbitMQ.Client.Events.AsyncEventHandler<RabbitMQ.Client.Events.BasicAckEventArgs!>!
-RabbitMQ.Client.IChannel.BasicNacksAsync -> RabbitMQ.Client.Events.AsyncEventHandler<RabbitMQ.Client.Events.BasicNackEventArgs!>!
-RabbitMQ.Client.IChannel.BasicReturnAsync -> RabbitMQ.Client.Events.AsyncEventHandler<RabbitMQ.Client.Events.BasicReturnEventArgs!>!
-RabbitMQ.Client.IChannel.CallbackExceptionAsync -> RabbitMQ.Client.Events.AsyncEventHandler<RabbitMQ.Client.Events.CallbackExceptionEventArgs!>!
diff --git a/projects/RabbitMQ.Client/client/api/IChannel.cs b/projects/RabbitMQ.Client/client/api/IChannel.cs
@@ -106,17 +106,17 @@ public interface IChannel : IDisposable
         /// <summary>
         /// Signalled when a Basic.Ack command arrives from the broker.
         /// </summary>
-        event AsyncEventHandler<BasicAckEventArgs> BasicAcksAsync;
+        event EventHandler<BasicAckEventArgs> BasicAcks;
 
         /// <summary>
         /// Signalled when a Basic.Nack command arrives from the broker.
         /// </summary>
-        event AsyncEventHandler<BasicNackEventArgs> BasicNacksAsync;
+        event EventHandler<BasicNackEventArgs> BasicNacks;
 
         /// <summary>
         /// Signalled when a Basic.Return command arrives from the broker.
         /// </summary>
-        event AsyncEventHandler<BasicReturnEventArgs> BasicReturnAsync;
+        event EventHandler<BasicReturnEventArgs> BasicReturn;
 
         /// <summary>
         /// Signalled when an exception occurs in a callback invoked by the channel.
@@ -127,15 +127,6 @@ public interface IChannel : IDisposable
         /// </summary>
         event EventHandler<CallbackExceptionEventArgs> CallbackException;
 
-        /// <summary>
-        /// Signalled when an exception occurs in an asynchronous callback invoked by the channel.
-        /// Examples of cases where this event will be signalled
-        /// include exceptions thrown in <see cref="IChannel.BasicAcksAsync"/>,
-        /// <see cref="IChannel.BasicNacksAsync"/>,
-        /// <see cref="IChannel.BasicReturnAsync"/> event handlers, etc.
-        /// </summary>
-        event AsyncEventHandler<CallbackExceptionEventArgs> CallbackExceptionAsync;
-
         event EventHandler<FlowControlEventArgs> FlowControl;
 
         /// <summary>
@@ -193,7 +184,7 @@ Task<string> BasicConsumeAsync(string queue, bool autoAck, string consumerTag, b
         /// <summary>
         /// Asynchronously retrieve an individual message, if
         /// one is available; returns null if the server answers that
-        /// no messages are currently available. See also <see cref="IChannel.BasicAckAsync(ulong, bool, CancellationToken)"/>
+        /// no messages are currently available. See also <see cref="IChannel.BasicAckAsync" />.
         /// </summary>
         /// <param name="queue">The queue.</param>
         /// <param name="autoAck">If set to <c>true</c>, automatically ack the message.</param>
@@ -277,9 +268,7 @@ Task CloseAsync(ShutdownEventArgs reason, bool abort,
         /// <summary>
         /// Asynchronously enable publisher confirmations.
         /// </summary>
-        /// <param name="trackConfirmations">Set to <c>false</c> if tracking via
-        /// <see cref="IChannel.BasicAckAsync(ulong, bool, CancellationToken)"/> and
-        /// <see cref="IChannel.BasicNackAsync(ulong, bool, bool, CancellationToken)"/> yourself.</param>
+        /// <param name="trackConfirmations">Set to <c>false</c> if tracking via <see cref="BasicAcks"/> and <see cref="BasicNacks"/> yourself.</param>
         /// <param name="cancellationToken">CancellationToken for this operation.</param>
         Task ConfirmSelectAsync(bool trackConfirmations = true,
             CancellationToken cancellationToken = default);
diff --git a/projects/RabbitMQ.Client/client/impl/AutorecoveringChannel.cs b/projects/RabbitMQ.Client/client/impl/AutorecoveringChannel.cs
@@ -79,22 +79,22 @@ public AutorecoveringChannel(AutorecoveringConnection conn, RecoveryAwareChannel
             _consumerDispatchConcurrency = consumerDispatchConcurrency;
         }
 
-        public event AsyncEventHandler<BasicAckEventArgs> BasicAcksAsync
+        public event EventHandler<BasicAckEventArgs> BasicAcks
         {
-            add => InnerChannel.BasicAcksAsync += value;
-            remove => InnerChannel.BasicAcksAsync -= value;
+            add => InnerChannel.BasicAcks += value;
+            remove => InnerChannel.BasicAcks -= value;
         }
 
-        public event AsyncEventHandler<BasicNackEventArgs> BasicNacksAsync
+        public event EventHandler<BasicNackEventArgs> BasicNacks
         {
-            add => InnerChannel.BasicNacksAsync += value;
-            remove => InnerChannel.BasicNacksAsync -= value;
+            add => InnerChannel.BasicNacks += value;
+            remove => InnerChannel.BasicNacks -= value;
         }
 
-        public event AsyncEventHandler<BasicReturnEventArgs> BasicReturnAsync
+        public event EventHandler<BasicReturnEventArgs> BasicReturn
         {
-            add => InnerChannel.BasicReturnAsync += value;
-            remove => InnerChannel.BasicReturnAsync -= value;
+            add => InnerChannel.BasicReturn += value;
+            remove => InnerChannel.BasicReturn -= value;
         }
 
         public event EventHandler<CallbackExceptionEventArgs> CallbackException
@@ -103,12 +103,6 @@ public event EventHandler<CallbackExceptionEventArgs> CallbackException
             remove => InnerChannel.CallbackException -= value;
         }
 
-        public event AsyncEventHandler<CallbackExceptionEventArgs> CallbackExceptionAsync
-        {
-            add => InnerChannel.CallbackExceptionAsync += value;
-            remove => InnerChannel.CallbackExceptionAsync -= value;
-        }
-
         public event EventHandler<FlowControlEventArgs> FlowControl
         {
             add { InnerChannel.FlowControl += value; }
diff --git a/projects/RabbitMQ.Client/client/impl/ChannelBase.cs b/projects/RabbitMQ.Client/client/impl/ChannelBase.cs
@@ -79,16 +79,11 @@ protected ChannelBase(ConnectionConfig config, ISession session,
             ContinuationTimeout = config.ContinuationTimeout;
             ConsumerDispatcher = new AsyncConsumerDispatcher(this,
                 perChannelConsumerDispatchConcurrency.GetValueOrDefault(config.ConsumerDispatchConcurrency));
-
-            void onException(Exception exception, string context) =>
+            Action<Exception, string> onException = (exception, context) =>
                 OnCallbackException(CallbackExceptionEventArgs.Build(exception, context));
-
-            Task onExceptionAsync(Exception exception, string context) =>
-                OnCallbackExceptionAsync(CallbackExceptionEventArgs.Build(exception, context));
-
-            _basicAcksWrapper = new AsyncEventingWrapper<BasicAckEventArgs>("OnBasicAck", onExceptionAsync);
-            _basicNacksWrapper = new AsyncEventingWrapper<BasicNackEventArgs>("OnBasicNack", onExceptionAsync);
-            _basicReturnWrapper = new AsyncEventingWrapper<BasicReturnEventArgs>("OnBasicReturn", onExceptionAsync);
+            _basicAcksWrapper = new EventingWrapper<BasicAckEventArgs>("OnBasicAck", onException);
+            _basicNacksWrapper = new EventingWrapper<BasicNackEventArgs>("OnBasicNack", onException);
+            _basicReturnWrapper = new EventingWrapper<BasicReturnEventArgs>("OnBasicReturn", onException);
             _callbackExceptionWrapper =
                 new EventingWrapper<CallbackExceptionEventArgs>(string.Empty, (exception, context) => { });
             _flowControlWrapper = new EventingWrapper<FlowControlEventArgs>("OnFlowControl", onException);
@@ -102,46 +97,44 @@ Task onExceptionAsync(Exception exception, string context) =>
         internal TimeSpan HandshakeContinuationTimeout { get; set; } = TimeSpan.FromSeconds(10);
         public TimeSpan ContinuationTimeout { get; set; }
 
-        public event AsyncEventHandler<BasicAckEventArgs> BasicAcksAsync
+        public event EventHandler<BasicAckEventArgs> BasicAcks
         {
             add => _basicAcksWrapper.AddHandler(value);
             remove => _basicAcksWrapper.RemoveHandler(value);
         }
-        private AsyncEventingWrapper<BasicAckEventArgs> _basicAcksWrapper;
 
-        public event AsyncEventHandler<BasicNackEventArgs> BasicNacksAsync
+        private EventingWrapper<BasicAckEventArgs> _basicAcksWrapper;
+
+        public event EventHandler<BasicNackEventArgs> BasicNacks
         {
             add => _basicNacksWrapper.AddHandler(value);
             remove => _basicNacksWrapper.RemoveHandler(value);
         }
-        private AsyncEventingWrapper<BasicNackEventArgs> _basicNacksWrapper;
 
-        public event AsyncEventHandler<BasicReturnEventArgs> BasicReturnAsync
+        private EventingWrapper<BasicNackEventArgs> _basicNacksWrapper;
+
+        public event EventHandler<BasicReturnEventArgs> BasicReturn
         {
             add => _basicReturnWrapper.AddHandler(value);
             remove => _basicReturnWrapper.RemoveHandler(value);
         }
-        private AsyncEventingWrapper<BasicReturnEventArgs> _basicReturnWrapper;
+
+        private EventingWrapper<BasicReturnEventArgs> _basicReturnWrapper;
 
         public event EventHandler<CallbackExceptionEventArgs> CallbackException
         {
             add => _callbackExceptionWrapper.AddHandler(value);
             remove => _callbackExceptionWrapper.RemoveHandler(value);
         }
-        private EventingWrapper<CallbackExceptionEventArgs> _callbackExceptionWrapper;
 
-        public event AsyncEventHandler<CallbackExceptionEventArgs> CallbackExceptionAsync
-        {
-            add => _callbackExceptionAsyncWrapper.AddHandler(value);
-            remove => _callbackExceptionAsyncWrapper.RemoveHandler(value);
-        }
-        private AsyncEventingWrapper<CallbackExceptionEventArgs> _callbackExceptionAsyncWrapper;
+        private EventingWrapper<CallbackExceptionEventArgs> _callbackExceptionWrapper;
 
         public event EventHandler<FlowControlEventArgs> FlowControl
         {
             add => _flowControlWrapper.AddHandler(value);
             remove => _flowControlWrapper.RemoveHandler(value);
         }
+
         private EventingWrapper<FlowControlEventArgs> _flowControlWrapper;
 
         public event EventHandler<ShutdownEventArgs> ChannelShutdown
@@ -159,13 +152,15 @@ public event EventHandler<ShutdownEventArgs> ChannelShutdown
             }
             remove => _channelShutdownWrapper.RemoveHandler(value);
         }
+
         private EventingWrapper<ShutdownEventArgs> _channelShutdownWrapper;
 
         public event EventHandler<EventArgs> Recovery
         {
             add => _recoveryWrapper.AddHandler(value);
             remove => _recoveryWrapper.RemoveHandler(value);
         }
+
         private EventingWrapper<EventArgs> _recoveryWrapper;
 
         internal void RunRecoveryEventHandlers(object sender)
@@ -472,11 +467,6 @@ internal void OnCallbackException(CallbackExceptionEventArgs args)
             _callbackExceptionWrapper.Invoke(this, args);
         }
 
-        internal Task OnCallbackExceptionAsync(CallbackExceptionEventArgs args)
-        {
-            return _callbackExceptionAsyncWrapper.InvokeAsync(this, args);
-        }
-
         ///<summary>Broadcasts notification of the final shutdown of the channel.</summary>
         ///<remarks>
         ///<para>
@@ -582,8 +572,7 @@ protected async Task<bool> HandleBasicAck(IncomingCommand cmd, CancellationToken
             if (!_basicAcksWrapper.IsEmpty)
             {
                 var args = new BasicAckEventArgs(ack._deliveryTag, ack._multiple);
-                await _basicAcksWrapper.InvokeAsync(this, args)
-                    .ConfigureAwait(false);
+                _basicAcksWrapper.Invoke(this, args);
             }
 
             await HandleAckNack(ack._deliveryTag, ack._multiple, false, cancellationToken)
@@ -598,8 +587,7 @@ protected async Task<bool> HandleBasicNack(IncomingCommand cmd, CancellationToke
             {
                 var args = new BasicNackEventArgs(
                     nack._deliveryTag, nack._multiple, nack._requeue);
-                await _basicNacksWrapper.InvokeAsync(this, args)
-                    .ConfigureAwait(false);
+                _basicNacksWrapper.Invoke(this, args);
             }
 
             await HandleAckNack(nack._deliveryTag, nack._multiple, true, cancellationToken)
@@ -640,19 +628,15 @@ protected virtual ulong AdjustDeliveryTag(ulong deliveryTag)
             return deliveryTag;
         }
 
-        protected Task HandleBasicReturn(IncomingCommand cmd)
+        protected void HandleBasicReturn(IncomingCommand cmd)
         {
             if (!_basicReturnWrapper.IsEmpty)
             {
                 var basicReturn = new BasicReturn(cmd.MethodSpan);
                 var e = new BasicReturnEventArgs(basicReturn._replyCode, basicReturn._replyText,
                     basicReturn._exchange, basicReturn._routingKey,
                     new ReadOnlyBasicProperties(cmd.HeaderSpan), cmd.Body.Memory);
-                return _basicReturnWrapper.InvokeAsync(this, e);
-            }
-            else
-            {
-                return Task.CompletedTask;
+                _basicReturnWrapper.Invoke(this, e);
             }
         }
 
diff --git a/projects/Test/Applications/PublisherConfirms/PublisherConfirms.cs b/projects/Test/Applications/PublisherConfirms/PublisherConfirms.cs
@@ -112,15 +112,15 @@ async Task HandlePublishConfirmsAsynchronously()
     var allMessagesConfirmedTcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
     var outstandingConfirms = new LinkedList<ulong>();
     var semaphore = new SemaphoreSlim(1, 1);
-    async Task CleanOutstandingConfirmsAsync(ulong deliveryTag, bool multiple)
+    void CleanOutstandingConfirms(ulong deliveryTag, bool multiple)
     {
         if (debug)
         {
             Console.WriteLine("{0} [DEBUG] confirming message: {1} (multiple: {2})",
                 DateTime.Now, deliveryTag, multiple);
         }
 
-        await semaphore.WaitAsync();
+        semaphore.Wait();
         try
         {
             if (multiple)
@@ -158,13 +158,11 @@ async Task CleanOutstandingConfirmsAsync(ulong deliveryTag, bool multiple)
         }
     }
 
-    channel.BasicAcksAsync += (sender, ea) =>
-        CleanOutstandingConfirmsAsync(ea.DeliveryTag, ea.Multiple);
-
-    channel.BasicNacksAsync += (sender, ea) =>
+    channel.BasicAcks += (sender, ea) => CleanOutstandingConfirms(ea.DeliveryTag, ea.Multiple);
+    channel.BasicNacks += (sender, ea) =>
     {
         Console.WriteLine($"{DateTime.Now} [WARNING] message sequence number: {ea.DeliveryTag} has been nacked (multiple: {ea.Multiple})");
-        return CleanOutstandingConfirmsAsync(ea.DeliveryTag, ea.Multiple);
+        CleanOutstandingConfirms(ea.DeliveryTag, ea.Multiple);
     };
 
     var sw = new Stopwatch();
diff --git a/projects/Test/Common/IntegrationFixture.cs b/projects/Test/Common/IntegrationFixture.cs
@@ -269,22 +269,6 @@ protected void AddCallbackExceptionHandlers(IConnection conn, IChannel channel)
                     {
                     }
                 };
-
-                channel.CallbackExceptionAsync += (o, ea) =>
-                {
-                    _channelCallbackException = ea.Exception;
-
-                    try
-                    {
-                        _output.WriteLine("{0} channel callback exception: {1}",
-                            _testDisplayName, _channelCallbackException);
-                    }
-                    catch (InvalidOperationException)
-                    {
-                    }
-
-                    return Task.CompletedTask;
-                };
             }
         }
 
diff --git a/projects/Test/Integration/ConnectionRecovery/TestBasicAckAndBasicNack.cs b/projects/Test/Integration/ConnectionRecovery/TestBasicAckAndBasicNack.cs
@@ -156,18 +156,8 @@ public async Task TestBasicAckEventHandlerRecovery()
         {
             await _channel.ConfirmSelectAsync();
             var tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-            ((AutorecoveringChannel)_channel).BasicAcksAsync += (m, args) =>
-            {
-                tcs.SetResult(true);
-                return Task.CompletedTask;
-            };
-
-            ((AutorecoveringChannel)_channel).BasicNacksAsync += (m, args) =>
-            {
-                tcs.SetResult(true);
-                return Task.CompletedTask;
-            };
+            ((AutorecoveringChannel)_channel).BasicAcks += (m, args) => tcs.SetResult(true);
+            ((AutorecoveringChannel)_channel).BasicNacks += (m, args) => tcs.SetResult(true);
 
             await CloseAndWaitForRecoveryAsync();
             await CloseAndWaitForRecoveryAsync();
diff --git a/projects/Test/Integration/TestConcurrentAccessWithSharedChannel.cs b/projects/Test/Integration/TestConcurrentAccessWithSharedChannel.cs
@@ -56,16 +56,14 @@ public async Task ConcurrentPublishSingleChannel()
         {
             int publishAckCount = 0;
 
-            _channel.BasicAcksAsync += (object sender, BasicAckEventArgs e) =>
+            _channel.BasicAcks += (object sender, BasicAckEventArgs e) =>
             {
                 Interlocked.Increment(ref publishAckCount);
-                return Task.CompletedTask;
             };
 
-            _channel.BasicNacksAsync += (object sender, BasicNackEventArgs e) =>
+            _channel.BasicNacks += (object sender, BasicNackEventArgs e) =>
             {
                 _output.WriteLine($"channel #{_channel.ChannelNumber} saw a nack, deliveryTag: {e.DeliveryTag}, multiple: {e.Multiple}");
-                return Task.CompletedTask;
             };
 
             await _channel.ConfirmSelectAsync(trackConfirmations: false);
diff --git a/projects/Test/Integration/TestConcurrentAccessWithSharedConnection.cs b/projects/Test/Integration/TestConcurrentAccessWithSharedConnection.cs
@@ -125,20 +125,18 @@ private Task TestConcurrentChannelOpenAndPublishingWithBodyAsync(byte[] body, in
 
                         await ch.ConfirmSelectAsync(trackConfirmations: false);
 
-                        ch.BasicAcksAsync += (object sender, BasicAckEventArgs e) =>
+                        ch.BasicAcks += (object sender, BasicAckEventArgs e) =>
                         {
                             if (e.DeliveryTag >= _messageCount)
                             {
                                 tcs.SetResult(true);
                             }
-                            return Task.CompletedTask;
                         };
 
-                        ch.BasicNacksAsync += (object sender, BasicNackEventArgs e) =>
+                        ch.BasicNacks += (object sender, BasicNackEventArgs e) =>
                         {
                             tcs.SetResult(false);
                             _output.WriteLine($"channel #{ch.ChannelNumber} saw a nack, deliveryTag: {e.DeliveryTag}, multiple: {e.Multiple}");
-                            return Task.CompletedTask;
                         };
 
                         QueueDeclareOk q = await ch.QueueDeclareAsync(queue: string.Empty, passive: false, durable: false, exclusive: true, autoDelete: true, arguments: null);
diff --git a/projects/Test/Integration/TestPublisherConfirms.cs b/projects/Test/Integration/TestPublisherConfirms.cs

Original file line number	Diff line number	Diff line change
`@@ -79,22 +79,22 @@ public AutorecoveringChannel(AutorecoveringConnection conn, RecoveryAwareChannel`
`79`	`79`	`_consumerDispatchConcurrency = consumerDispatchConcurrency;`
`80`	`80`	`}`
`81`	`81`
`82`		`- public event AsyncEventHandler<BasicAckEventArgs> BasicAcksAsync`
	`82`	`+ public event EventHandler<BasicAckEventArgs> BasicAcks`
`83`	`83`	`{`
`84`		`- add => InnerChannel.BasicAcksAsync += value;`
`85`		`- remove => InnerChannel.BasicAcksAsync -= value;`
	`84`	`+ add => InnerChannel.BasicAcks += value;`
	`85`	`+ remove => InnerChannel.BasicAcks -= value;`
`86`	`86`	`}`
`87`	`87`
`88`		`- public event AsyncEventHandler<BasicNackEventArgs> BasicNacksAsync`
	`88`	`+ public event EventHandler<BasicNackEventArgs> BasicNacks`
`89`	`89`	`{`
`90`		`- add => InnerChannel.BasicNacksAsync += value;`
`91`		`- remove => InnerChannel.BasicNacksAsync -= value;`
	`90`	`+ add => InnerChannel.BasicNacks += value;`
	`91`	`+ remove => InnerChannel.BasicNacks -= value;`
`92`	`92`	`}`
`93`	`93`
`94`		`- public event AsyncEventHandler<BasicReturnEventArgs> BasicReturnAsync`
	`94`	`+ public event EventHandler<BasicReturnEventArgs> BasicReturn`
`95`	`95`	`{`
`96`		`- add => InnerChannel.BasicReturnAsync += value;`
`97`		`- remove => InnerChannel.BasicReturnAsync -= value;`
	`96`	`+ add => InnerChannel.BasicReturn += value;`
	`97`	`+ remove => InnerChannel.BasicReturn -= value;`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`public event EventHandler<CallbackExceptionEventArgs> CallbackException`
`@@ -103,12 +103,6 @@ public event EventHandler<CallbackExceptionEventArgs> CallbackException`
`103`	`103`	`remove => InnerChannel.CallbackException -= value;`
`104`	`104`	`}`
`105`	`105`
`106`		`- public event AsyncEventHandler<CallbackExceptionEventArgs> CallbackExceptionAsync`
`107`		`- {`
`108`		`- add => InnerChannel.CallbackExceptionAsync += value;`
`109`		`- remove => InnerChannel.CallbackExceptionAsync -= value;`
`110`		`- }`
`111`		`-`
`112`	`106`	`public event EventHandler<FlowControlEventArgs> FlowControl`
`113`	`107`	`{`
`114`	`108`	`add { InnerChannel.FlowControl += value; }`
Original file line number	Diff line number	Diff line change
`@@ -112,15 +112,15 @@ async Task HandlePublishConfirmsAsynchronously()`
`112`	`112`	`var allMessagesConfirmedTcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);`
`113`	`113`	`var outstandingConfirms = new LinkedList<ulong>();`
`114`	`114`	`var semaphore = new SemaphoreSlim(1, 1);`
`115`		`- async Task CleanOutstandingConfirmsAsync(ulong deliveryTag, bool multiple)`
	`115`	`+ void CleanOutstandingConfirms(ulong deliveryTag, bool multiple)`
`116`	`116`	`{`
`117`	`117`	`if (debug)`
`118`	`118`	`{`
`119`	`119`	`Console.WriteLine("{0} [DEBUG] confirming message: {1} (multiple: {2})",`
`120`	`120`	`DateTime.Now, deliveryTag, multiple);`
`121`	`121`	`}`
`122`	`122`
`123`		`- await semaphore.WaitAsync();`
	`123`	`+ semaphore.Wait();`
`124`	`124`	`try`
`125`	`125`	`{`
`126`	`126`	`if (multiple)`
`@@ -158,13 +158,11 @@ async Task CleanOutstandingConfirmsAsync(ulong deliveryTag, bool multiple)`
`158`	`158`	`}`
`159`	`159`	`}`
`160`	`160`
`161`		`- channel.BasicAcksAsync += (sender, ea) =>`
`162`		`- CleanOutstandingConfirmsAsync(ea.DeliveryTag, ea.Multiple);`
`163`		`-`
`164`		`- channel.BasicNacksAsync += (sender, ea) =>`
	`161`	`+ channel.BasicAcks += (sender, ea) => CleanOutstandingConfirms(ea.DeliveryTag, ea.Multiple);`
	`162`	`+ channel.BasicNacks += (sender, ea) =>`
`165`	`163`	`{`
`166`	`164`	`Console.WriteLine($"{DateTime.Now} [WARNING] message sequence number: {ea.DeliveryTag} has been nacked (multiple: {ea.Multiple})");`
`167`		`- return CleanOutstandingConfirmsAsync(ea.DeliveryTag, ea.Multiple);`
	`165`	`+ CleanOutstandingConfirms(ea.DeliveryTag, ea.Multiple);`
`168`	`166`	`};`
`169`	`167`
`170`	`168`	`var sw = new Stopwatch();`
Original file line number	Diff line number	Diff line change
`@@ -269,22 +269,6 @@ protected void AddCallbackExceptionHandlers(IConnection conn, IChannel channel)`
`269`	`269`	`{`
`270`	`270`	`}`
`271`	`271`	`};`
`272`		`-`
`273`		`- channel.CallbackExceptionAsync += (o, ea) =>`
`274`		`- {`
`275`		`- _channelCallbackException = ea.Exception;`
`276`		`-`
`277`		`- try`
`278`		`- {`
`279`		`- _output.WriteLine("{0} channel callback exception: {1}",`
`280`		`- _testDisplayName, _channelCallbackException);`
`281`		`- }`
`282`		`- catch (InvalidOperationException)`
`283`		`- {`
`284`		`- }`
`285`		`-`
`286`		`- return Task.CompletedTask;`
`287`		`- };`
`288`	`272`	`}`
`289`	`273`	`}`
`290`	`274`
Original file line number	Diff line number	Diff line change
`@@ -56,16 +56,14 @@ public async Task ConcurrentPublishSingleChannel()`
`56`	`56`	`{`
`57`	`57`	`int publishAckCount = 0;`
`58`	`58`
`59`		`- _channel.BasicAcksAsync += (object sender, BasicAckEventArgs e) =>`
	`59`	`+ _channel.BasicAcks += (object sender, BasicAckEventArgs e) =>`
`60`	`60`	`{`
`61`	`61`	`Interlocked.Increment(ref publishAckCount);`
`62`		`- return Task.CompletedTask;`
`63`	`62`	`};`
`64`	`63`
`65`		`- _channel.BasicNacksAsync += (object sender, BasicNackEventArgs e) =>`
	`64`	`+ _channel.BasicNacks += (object sender, BasicNackEventArgs e) =>`
`66`	`65`	`{`
`67`	`66`	`_output.WriteLine($"channel #{_channel.ChannelNumber} saw a nack, deliveryTag: {e.DeliveryTag}, multiple: {e.Multiple}");`
`68`		`- return Task.CompletedTask;`
`69`	`67`	`};`
`70`	`68`
`71`	`69`	`await _channel.ConfirmSelectAsync(trackConfirmations: false);`
Original file line number	Diff line number	Diff line change
`@@ -125,20 +125,18 @@ private Task TestConcurrentChannelOpenAndPublishingWithBodyAsync(byte[] body, in`
`125`	`125`
`126`	`126`	`await ch.ConfirmSelectAsync(trackConfirmations: false);`
`127`	`127`
`128`		`- ch.BasicAcksAsync += (object sender, BasicAckEventArgs e) =>`
	`128`	`+ ch.BasicAcks += (object sender, BasicAckEventArgs e) =>`
`129`	`129`	`{`
`130`	`130`	`if (e.DeliveryTag >= _messageCount)`
`131`	`131`	`{`
`132`	`132`	`tcs.SetResult(true);`
`133`	`133`	`}`
`134`		`- return Task.CompletedTask;`
`135`	`134`	`};`
`136`	`135`
`137`		`- ch.BasicNacksAsync += (object sender, BasicNackEventArgs e) =>`
	`136`	`+ ch.BasicNacks += (object sender, BasicNackEventArgs e) =>`
`138`	`137`	`{`
`139`	`138`	`tcs.SetResult(false);`
`140`	`139`	`_output.WriteLine($"channel #{ch.ChannelNumber} saw a nack, deliveryTag: {e.DeliveryTag}, multiple: {e.Multiple}");`
`141`		`- return Task.CompletedTask;`
`142`	`140`	`};`
`143`	`141`
`144`	`142`	`QueueDeclareOk q = await ch.QueueDeclareAsync(queue: string.Empty, passive: false, durable: false, exclusive: true, autoDelete: true, arguments: null);`