Simplify wrapper to take token from arg

danielmarbach · danielmarbach · commit c2f4c19c14c3 · 2024-09-19T11:18:56.000+02:00
diff --git a/projects/RabbitMQ.Client/client/events/AsyncEventingBasicConsumer.cs b/projects/RabbitMQ.Client/client/events/AsyncEventingBasicConsumer.cs
@@ -58,7 +58,7 @@ await base.OnCancelAsync(consumerTags, cancellationToken)
                 .ConfigureAwait(false);
             if (!_unregisteredWrapper.IsEmpty)
             {
-                await _unregisteredWrapper.InvokeAsync(this, new ConsumerEventArgs(consumerTags, cancellationToken), cancellationToken)
+                await _unregisteredWrapper.InvokeAsync(this, new ConsumerEventArgs(consumerTags, cancellationToken))
                     .ConfigureAwait(false);
             }
         }
@@ -70,7 +70,7 @@ await base.HandleBasicConsumeOkAsync(consumerTag, cancellationToken)
                 .ConfigureAwait(false);
             if (!_registeredWrapper.IsEmpty)
             {
-                await _registeredWrapper.InvokeAsync(this, new ConsumerEventArgs(new[] { consumerTag }, cancellationToken), cancellationToken)
+                await _registeredWrapper.InvokeAsync(this, new ConsumerEventArgs(new[] { consumerTag }, cancellationToken))
                     .ConfigureAwait(false);
             }
         }
@@ -82,7 +82,7 @@ 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, cancellationToken);
+            return _receivedWrapper.InvokeAsync(this, deliverEventArgs);
         }
 
         ///<summary>Fires the Shutdown event.</summary>
@@ -92,7 +92,7 @@ await base.HandleChannelShutdownAsync(channel, reason)
                 .ConfigureAwait(false);
             if (!_shutdownWrapper.IsEmpty)
             {
-                await _shutdownWrapper.InvokeAsync(this, reason, reason.CancellationToken)
+                await _shutdownWrapper.InvokeAsync(this, reason)
                     .ConfigureAwait(false);
             }
         }
diff --git a/projects/RabbitMQ.Client/client/impl/AsyncEventingWrapper.cs b/projects/RabbitMQ.Client/client/impl/AsyncEventingWrapper.cs
@@ -5,9 +5,9 @@
 
 namespace RabbitMQ.Client.Impl
 {
-    internal struct AsyncEventingWrapper<T> where T : AsyncEventArgs
+    internal struct AsyncEventingWrapper<TEvent> where TEvent : AsyncEventArgs
     {
-        private event AsyncEventHandler<T>? _event;
+        private event AsyncEventHandler<TEvent>? _event;
         private Delegate[]? _handlers;
         private string? _context;
         private Func<Exception, string, CancellationToken, Task>? _onException;
@@ -22,20 +22,20 @@ public AsyncEventingWrapper(string context, Func<Exception, string, Cancellation
             _onException = onException;
         }
 
-        public void AddHandler(AsyncEventHandler<T>? handler)
+        public void AddHandler(AsyncEventHandler<TEvent>? handler)
         {
             _event += handler;
             _handlers = null;
         }
 
-        public void RemoveHandler(AsyncEventHandler<T>? handler)
+        public void RemoveHandler(AsyncEventHandler<TEvent>? handler)
         {
             _event -= handler;
             _handlers = null;
         }
 
         // Do not make this function async! (This type is a struct that gets copied at the start of an async method => empty _handlers is copied)
-        public Task InvokeAsync(object sender, T parameter, CancellationToken cancellationToken = default)
+        public Task InvokeAsync(object sender, TEvent parameter)
         {
             Delegate[]? handlers = _handlers;
             if (handlers is null)
@@ -49,23 +49,23 @@ public Task InvokeAsync(object sender, T parameter, CancellationToken cancellati
                 _handlers = handlers;
             }
 
-            return InternalInvoke(handlers, sender, parameter, cancellationToken);
+            return InternalInvoke(handlers, sender, parameter);
         }
 
-        private readonly async Task InternalInvoke(Delegate[] handlers, object sender, T parameter, CancellationToken cancellationToken)
+        private readonly async Task InternalInvoke(Delegate[] handlers, object sender, TEvent @event)
         {
-            foreach (AsyncEventHandler<T> action in handlers)
+            foreach (AsyncEventHandler<TEvent> action in handlers)
             {
                 try
                 {
-                    await action(sender, parameter)
+                    await action(sender, @event)
                         .ConfigureAwait(false);
                 }
                 catch (Exception exception)
                 {
                     if (_onException != null)
                     {
-                        await _onException(exception, _context!, cancellationToken)
+                        await _onException(exception, _context!, @event.CancellationToken)
                             .ConfigureAwait(false);
                     }
                     else
@@ -76,7 +76,7 @@ await _onException(exception, _context!, cancellationToken)
             }
         }
 
-        public void Takeover(in AsyncEventingWrapper<T> other)
+        public void Takeover(in AsyncEventingWrapper<TEvent> other)
         {
             _event = other._event;
             _handlers = other._handlers;

Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ await base.OnCancelAsync(consumerTags, cancellationToken)`
`58`	`58`	`.ConfigureAwait(false);`
`59`	`59`	`if (!_unregisteredWrapper.IsEmpty)`
`60`	`60`	`{`
`61`		`- await _unregisteredWrapper.InvokeAsync(this, new ConsumerEventArgs(consumerTags, cancellationToken), cancellationToken)`
	`61`	`+ await _unregisteredWrapper.InvokeAsync(this, new ConsumerEventArgs(consumerTags, cancellationToken))`
`62`	`62`	`.ConfigureAwait(false);`
`63`	`63`	`}`
`64`	`64`	`}`
`@@ -70,7 +70,7 @@ await base.HandleBasicConsumeOkAsync(consumerTag, cancellationToken)`
`70`	`70`	`.ConfigureAwait(false);`
`71`	`71`	`if (!_registeredWrapper.IsEmpty)`
`72`	`72`	`{`
`73`		`- await _registeredWrapper.InvokeAsync(this, new ConsumerEventArgs(new[] { consumerTag }, cancellationToken), cancellationToken)`
	`73`	`+ await _registeredWrapper.InvokeAsync(this, new ConsumerEventArgs(new[] { consumerTag }, cancellationToken))`
`74`	`74`	`.ConfigureAwait(false);`
`75`	`75`	`}`
`76`	`76`	`}`
`@@ -82,7 +82,7 @@ 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, cancellationToken);`
	`85`	`+ return _receivedWrapper.InvokeAsync(this, deliverEventArgs);`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`///<summary>Fires the Shutdown event.</summary>`
`@@ -92,7 +92,7 @@ await base.HandleChannelShutdownAsync(channel, reason)`
`92`	`92`	`.ConfigureAwait(false);`
`93`	`93`	`if (!_shutdownWrapper.IsEmpty)`
`94`	`94`	`{`
`95`		`- await _shutdownWrapper.InvokeAsync(this, reason, reason.CancellationToken)`
	`95`	`+ await _shutdownWrapper.InvokeAsync(this, reason)`
`96`	`96`	`.ConfigureAwait(false);`
`97`	`97`	`}`
`98`	`98`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,9 +5,9 @@`
`5`	`5`
`6`	`6`	`namespace RabbitMQ.Client.Impl`
`7`	`7`	`{`
`8`		`- internal struct AsyncEventingWrapper<T> where T : AsyncEventArgs`
	`8`	`+ internal struct AsyncEventingWrapper<TEvent> where TEvent : AsyncEventArgs`
`9`	`9`	`{`
`10`		`- private event AsyncEventHandler<T>? _event;`
	`10`	`+ private event AsyncEventHandler<TEvent>? _event;`
`11`	`11`	`private Delegate[]? _handlers;`
`12`	`12`	`private string? _context;`
`13`	`13`	`private Func<Exception, string, CancellationToken, Task>? _onException;`
`@@ -22,20 +22,20 @@ public AsyncEventingWrapper(string context, Func<Exception, string, Cancellation`
`22`	`22`	`_onException = onException;`
`23`	`23`	`}`
`24`	`24`
`25`		`- public void AddHandler(AsyncEventHandler<T>? handler)`
	`25`	`+ public void AddHandler(AsyncEventHandler<TEvent>? handler)`
`26`	`26`	`{`
`27`	`27`	`_event += handler;`
`28`	`28`	`_handlers = null;`
`29`	`29`	`}`
`30`	`30`
`31`		`- public void RemoveHandler(AsyncEventHandler<T>? handler)`
	`31`	`+ public void RemoveHandler(AsyncEventHandler<TEvent>? handler)`
`32`	`32`	`{`
`33`	`33`	`_event -= handler;`
`34`	`34`	`_handlers = null;`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`// Do not make this function async! (This type is a struct that gets copied at the start of an async method => empty _handlers is copied)`
`38`		`- public Task InvokeAsync(object sender, T parameter, CancellationToken cancellationToken = default)`
	`38`	`+ public Task InvokeAsync(object sender, TEvent parameter)`
`39`	`39`	`{`
`40`	`40`	`Delegate[]? handlers = _handlers;`
`41`	`41`	`if (handlers is null)`
`@@ -49,23 +49,23 @@ public Task InvokeAsync(object sender, T parameter, CancellationToken cancellati`
`49`	`49`	`_handlers = handlers;`
`50`	`50`	`}`
`51`	`51`
`52`		`- return InternalInvoke(handlers, sender, parameter, cancellationToken);`
	`52`	`+ return InternalInvoke(handlers, sender, parameter);`
`53`	`53`	`}`
`54`	`54`
`55`		`- private readonly async Task InternalInvoke(Delegate[] handlers, object sender, T parameter, CancellationToken cancellationToken)`
	`55`	`+ private readonly async Task InternalInvoke(Delegate[] handlers, object sender, TEvent @event)`
`56`	`56`	`{`
`57`		`- foreach (AsyncEventHandler<T> action in handlers)`
	`57`	`+ foreach (AsyncEventHandler<TEvent> action in handlers)`
`58`	`58`	`{`
`59`	`59`	`try`
`60`	`60`	`{`
`61`		`- await action(sender, parameter)`
	`61`	`+ await action(sender, @event)`
`62`	`62`	`.ConfigureAwait(false);`
`63`	`63`	`}`
`64`	`64`	`catch (Exception exception)`
`65`	`65`	`{`
`66`	`66`	`if (_onException != null)`
`67`	`67`	`{`
`68`		`- await _onException(exception, _context!, cancellationToken)`
	`68`	`+ await _onException(exception, _context!, @event.CancellationToken)`
`69`	`69`	`.ConfigureAwait(false);`
`70`	`70`	`}`
`71`	`71`	`else`
`@@ -76,7 +76,7 @@ await _onException(exception, _context!, cancellationToken)`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`
`79`		`- public void Takeover(in AsyncEventingWrapper<T> other)`
	`79`	`+ public void Takeover(in AsyncEventingWrapper<TEvent> other)`
`80`	`80`	`{`
`81`	`81`	`_event = other._event;`
`82`	`82`	`_handlers = other._handlers;`