* Dispose -> DisposeAsync

lukebakken · lukebakken · commit 56b162548ee0 · 2024-09-24T08:30:23.000-07:00
diff --git a/projects/Test/Applications/CreateChannel/Program.cs b/projects/Test/Applications/CreateChannel/Program.cs
@@ -36,7 +36,7 @@ public static async Task Main()
 
                     for (int j = 0; j < channels.Length; j++)
                     {
-                        channels[j].Dispose();
+                        await channels[j].DisposeAsync();
                     }
                 }
 
diff --git a/projects/Test/Common/IntegrationFixture.cs b/projects/Test/Common/IntegrationFixture.cs
@@ -190,8 +190,14 @@ public virtual async Task DisposeAsync()
             finally
             {
                 _eventListener?.Dispose();
-                _channel?.Dispose();
-                _conn?.Dispose();
+                if (_channel is not null)
+                {
+                    await _channel.DisposeAsync();
+                }
+                if (_conn is not null)
+                {
+                    await _conn.DisposeAsync();
+                }
                 _channel = null;
                 _conn = null;
             }
diff --git a/projects/Test/Integration/ConnectionRecovery/TestConnectionRecovery.cs b/projects/Test/Integration/ConnectionRecovery/TestConnectionRecovery.cs
@@ -75,7 +75,7 @@ await _channel.ExchangeDeclareAsync(exchange: exchangeName,
             await _channel.QueueBindAsync(queue: queueName, exchange: exchangeName, routingKey: routingKey);
 
             await _channel.CloseAsync();
-            _channel.Dispose();
+            await _channel.DisposeAsync();
             _channel = null;
 
             _channel = await _conn.CreateChannelAsync();
diff --git a/projects/Test/Integration/TestAsyncConsumer.cs b/projects/Test/Integration/TestAsyncConsumer.cs
@@ -686,9 +686,9 @@ public async Task TestCloseWithinEventHandler_GH1567()
             {
                 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
-                _channel.CloseAsync().ContinueWith((_) =>
+                _channel.CloseAsync().ContinueWith(async (_) =>
                 {
-                    _channel.Dispose();
+                    await _channel.DisposeAsync();
                     _channel = null;
                 });
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
diff --git a/projects/Test/Integration/TestChannelAllocation.cs b/projects/Test/Integration/TestChannelAllocation.cs
@@ -73,7 +73,7 @@ public async Task AllocateInOrder()
             foreach (IChannel channel in channels)
             {
                 await channel.CloseAsync();
-                channel.Dispose();
+                await channel.DisposeAsync();
             }
         }
 
@@ -90,7 +90,7 @@ public async Task AllocateInOrderOnlyUsingDispose()
 
             foreach (IChannel channel in channels)
             {
-                channel.Dispose();
+                await channel.DisposeAsync();
             }
         }
 
@@ -100,12 +100,12 @@ public async Task AllocateAfterFreeingLast()
             IChannel ch0 = await _c.CreateChannelAsync();
             Assert.Equal(1, ChannelNumber(ch0));
             await ch0.CloseAsync();
-            ch0.Dispose();
+            await ch0.DisposeAsync();
 
             IChannel ch1 = await _c.CreateChannelAsync();
             Assert.Equal(1, ChannelNumber(ch1));
             await ch1.CloseAsync();
-            ch1.Dispose();
+            await ch1.DisposeAsync();
         }
 
         [Fact]
@@ -121,6 +121,7 @@ public async Task AllocateAfterFreeingMany()
             foreach (IChannel channel in channels)
             {
                 await channel.CloseAsync();
+                await channel.DisposeAsync();
             }
 
             channels.Clear();
@@ -139,6 +140,7 @@ public async Task AllocateAfterFreeingMany()
             {
                 Assert.Equal(k++, ChannelNumber(channel));
                 await channel.CloseAsync();
+                await channel.DisposeAsync();
             }
         }
 
diff --git a/projects/Test/Integration/TestConnectionFactory.cs b/projects/Test/Integration/TestConnectionFactory.cs
@@ -241,7 +241,7 @@ public async Task TestCreateConnectionWithoutAutoRecoverySelectsAHostFromTheList
 
             IConnection conn = await cf.CreateConnectionAsync(new List<string> { "localhost" });
             await conn.CloseAsync();
-            conn.Dispose();
+            await conn.DisposeAsync();
             Assert.Equal("not_localhost", cf.HostName);
             Assert.Equal("localhost", conn.Endpoint.HostName);
         }
diff --git a/projects/Test/Integration/TestConnectionShutdown.cs b/projects/Test/Integration/TestConnectionShutdown.cs
@@ -107,7 +107,7 @@ public async Task TestDisposedWithSocketClosedOutOfBand()
 
             try
             {
-                _conn.Dispose();
+                await _conn.DisposeAsync();
                 await WaitAsync(tcs, WaitSpan, "channel shutdown");
                 await frameHandlerCloseTask.AsTask().WaitAsync(WaitSpan);
             }
@@ -145,7 +145,7 @@ public async Task TestShutdownSignalPropagationToChannelsUsingDispose()
                 return Task.CompletedTask;
             };
 
-            _conn.Dispose();
+            await _conn.DisposeAsync();
             _conn = null;
 
             await WaitAsync(tcs, TimeSpan.FromSeconds(3), "channel shutdown");
@@ -172,7 +172,7 @@ public async Task TestConsumerDispatcherShutdown()
         public async Task TestDisposeAfterAbort_GH825()
         {
             await _channel.AbortAsync();
-            _channel.Dispose();
+            await _channel.DisposeAsync();
         }
     }
 }
diff --git a/projects/Test/Integration/TestConnectionTopologyRecovery.cs b/projects/Test/Integration/TestConnectionTopologyRecovery.cs
@@ -131,8 +131,8 @@ public async Task TestTopologyRecoveryQueueFilter()
             {
                 await ch.CloseAsync();
                 await conn.CloseAsync();
-                ch.Dispose();
-                conn.Dispose();
+                await ch.DisposeAsync();
+                await conn.DisposeAsync();
             }
         }
 
@@ -180,8 +180,8 @@ public async Task TestTopologyRecoveryExchangeFilter()
             {
                 await ch.CloseAsync();
                 await conn.CloseAsync();
-                ch.Dispose();
-                conn.Dispose();
+                await ch.DisposeAsync();
+                await conn.DisposeAsync();
             }
         }
 
@@ -237,8 +237,8 @@ public async Task TestTopologyRecoveryBindingFilter()
                 await ch.QueueDeleteAsync(queueWithIgnoredBinding);
                 await ch.CloseAsync();
                 await conn.CloseAsync();
-                ch.Dispose();
-                conn.Dispose();
+                await ch.DisposeAsync();
+                await conn.DisposeAsync();
             }
         }
 
@@ -325,8 +325,8 @@ public async Task TestTopologyRecoveryDefaultFilterRecoversAllEntities()
             {
                 await ch.CloseAsync();
                 await conn.CloseAsync();
-                ch.Dispose();
-                conn.Dispose();
+                await ch.DisposeAsync();
+                await conn.DisposeAsync();
             }
         }
 
@@ -390,8 +390,8 @@ await _channel.QueueDeclareAsync(queueToRecoverWithException, false, false, fals
                 await _channel.QueueDeleteAsync(queueToRecoverWithException);
                 await ch.CloseAsync();
                 await conn.CloseAsync();
-                ch.Dispose();
-                conn.Dispose();
+                await ch.DisposeAsync();
+                await conn.DisposeAsync();
             }
         }
 
@@ -449,8 +449,8 @@ public async Task TestTopologyRecoveryExchangeExceptionHandler()
 
                 await ch.CloseAsync();
                 await conn.CloseAsync();
-                ch.Dispose();
-                conn.Dispose();
+                await ch.DisposeAsync();
+                await conn.DisposeAsync();
             }
         }
 
@@ -513,8 +513,8 @@ public async Task TestTopologyRecoveryBindingExceptionHandler()
 
             await ch.CloseAsync();
             await conn.CloseAsync();
-            ch.Dispose();
-            conn.Dispose();
+            await ch.DisposeAsync();
+            await conn.DisposeAsync();
         }
 
         [Fact]
@@ -590,8 +590,8 @@ public async Task TestTopologyRecoveryConsumerExceptionHandler()
             {
                 await ch.CloseAsync();
                 await conn.CloseAsync();
-                ch.Dispose();
-                conn.Dispose();
+                await ch.DisposeAsync();
+                await conn.DisposeAsync();
             }
         }
     }
diff --git a/projects/Test/OAuth2/TestOAuth2.cs b/projects/Test/OAuth2/TestOAuth2.cs
@@ -116,13 +116,13 @@ public async Task DisposeAsync()
                 if (_connection != null)
                 {
                     await _connection.CloseAsync();
+                    await _connection.DisposeAsync();
                 }
             }
             finally
             {
                 _doneEvent.Dispose();
                 _producerCredentialsProvider?.Dispose();
-                _connection?.Dispose();
                 _cancellationTokenSource.Dispose();
             }
         }
@@ -224,7 +224,7 @@ public async Task SecondConnectionCrashes_GH1429()
             Assert.NotNull(_connectionFactory);
             // https://github.com/rabbitmq/rabbitmq-dotnet-client/issues/1429
             IConnection secondConnection = await _connectionFactory.CreateConnectionAsync(CancellationToken.None);
-            secondConnection.Dispose();
+            await secondConnection.DisposeAsync();
         }
 
         private async Task<IChannel> DeclarePublishChannelAsync()
diff --git a/projects/Test/SequentialIntegration/TestConnectionBlocked.cs b/projects/Test/SequentialIntegration/TestConnectionBlocked.cs
@@ -89,7 +89,7 @@ public async Task TestDisposeOnBlockedConnectionDoesNotHang()
                 try
                 {
                     await _conn.AbortAsync();
-                    _conn.Dispose();
+                    await _conn.DisposeAsync();
                     tcs.SetResult(true);
                 }
                 catch (Exception)
diff --git a/projects/Test/SequentialIntegration/TestConnectionRecovery.cs b/projects/Test/SequentialIntegration/TestConnectionRecovery.cs
@@ -135,7 +135,7 @@ Task _channel_ChannelShutdownAsync(object sender, ShutdownEventArgs e)
             Assert.False(_channel.IsClosed);
 
             await _channel.CloseAsync();
-            _channel.Dispose();
+            await _channel.DisposeAsync();
             Assert.True(_channel.IsClosed);
             _channel = null;
 

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ public static async Task Main()`
`36`	`36`
`37`	`37`	`for (int j = 0; j < channels.Length; j++)`
`38`	`38`	`{`
`39`		`- channels[j].Dispose();`
	`39`	`+ await channels[j].DisposeAsync();`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
Original file line number	Diff line number	Diff line change
`@@ -686,9 +686,9 @@ public async Task TestCloseWithinEventHandler_GH1567()`
`686`	`686`	`{`
`687`	`687`	`await _channel.BasicCancelAsync(eventArgs.ConsumerTag);`
`688`	`688`	`#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed`
`689`		`- _channel.CloseAsync().ContinueWith((_) =>`
	`689`	`+ _channel.CloseAsync().ContinueWith(async (_) =>`
`690`	`690`	`{`
`691`		`- _channel.Dispose();`
	`691`	`+ await _channel.DisposeAsync();`
`692`	`692`	`_channel = null;`
`693`	`693`	`});`
`694`	`694`	`#pragma warning restore 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
`@@ -73,7 +73,7 @@ public async Task AllocateInOrder()`
`73`	`73`	`foreach (IChannel channel in channels)`
`74`	`74`	`{`
`75`	`75`	`await channel.CloseAsync();`
`76`		`- channel.Dispose();`
	`76`	`+ await channel.DisposeAsync();`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`
`@@ -90,7 +90,7 @@ public async Task AllocateInOrderOnlyUsingDispose()`
`90`	`90`
`91`	`91`	`foreach (IChannel channel in channels)`
`92`	`92`	`{`
`93`		`- channel.Dispose();`
	`93`	`+ await channel.DisposeAsync();`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`
`@@ -100,12 +100,12 @@ public async Task AllocateAfterFreeingLast()`
`100`	`100`	`IChannel ch0 = await _c.CreateChannelAsync();`
`101`	`101`	`Assert.Equal(1, ChannelNumber(ch0));`
`102`	`102`	`await ch0.CloseAsync();`
`103`		`- ch0.Dispose();`
	`103`	`+ await ch0.DisposeAsync();`
`104`	`104`
`105`	`105`	`IChannel ch1 = await _c.CreateChannelAsync();`
`106`	`106`	`Assert.Equal(1, ChannelNumber(ch1));`
`107`	`107`	`await ch1.CloseAsync();`
`108`		`- ch1.Dispose();`
	`108`	`+ await ch1.DisposeAsync();`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`[Fact]`
`@@ -121,6 +121,7 @@ public async Task AllocateAfterFreeingMany()`
`121`	`121`	`foreach (IChannel channel in channels)`
`122`	`122`	`{`
`123`	`123`	`await channel.CloseAsync();`
	`124`	`+ await channel.DisposeAsync();`
`124`	`125`	`}`
`125`	`126`
`126`	`127`	`channels.Clear();`
`@@ -139,6 +140,7 @@ public async Task AllocateAfterFreeingMany()`
`139`	`140`	`{`
`140`	`141`	`Assert.Equal(k++, ChannelNumber(channel));`
`141`	`142`	`await channel.CloseAsync();`
	`143`	`+ await channel.DisposeAsync();`
`142`	`144`	`}`
`143`	`145`	`}`
`144`	`146`
Original file line number	Diff line number	Diff line change
`@@ -241,7 +241,7 @@ public async Task TestCreateConnectionWithoutAutoRecoverySelectsAHostFromTheList`
`241`	`241`
`242`	`242`	`IConnection conn = await cf.CreateConnectionAsync(new List<string> { "localhost" });`
`243`	`243`	`await conn.CloseAsync();`
`244`		`- conn.Dispose();`
	`244`	`+ await conn.DisposeAsync();`
`245`	`245`	`Assert.Equal("not_localhost", cf.HostName);`
`246`	`246`	`Assert.Equal("localhost", conn.Endpoint.HostName);`
`247`	`247`	`}`
Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ public async Task TestDisposedWithSocketClosedOutOfBand()`
`107`	`107`
`108`	`108`	`try`
`109`	`109`	`{`
`110`		`- _conn.Dispose();`
	`110`	`+ await _conn.DisposeAsync();`
`111`	`111`	`await WaitAsync(tcs, WaitSpan, "channel shutdown");`
`112`	`112`	`await frameHandlerCloseTask.AsTask().WaitAsync(WaitSpan);`
`113`	`113`	`}`
`@@ -145,7 +145,7 @@ public async Task TestShutdownSignalPropagationToChannelsUsingDispose()`
`145`	`145`	`return Task.CompletedTask;`
`146`	`146`	`};`
`147`	`147`
`148`		`- _conn.Dispose();`
	`148`	`+ await _conn.DisposeAsync();`
`149`	`149`	`_conn = null;`
`150`	`150`
`151`	`151`	`await WaitAsync(tcs, TimeSpan.FromSeconds(3), "channel shutdown");`
`@@ -172,7 +172,7 @@ public async Task TestConsumerDispatcherShutdown()`
`172`	`172`	`public async Task TestDisposeAfterAbort_GH825()`
`173`	`173`	`{`
`174`	`174`	`await _channel.AbortAsync();`
`175`		`- _channel.Dispose();`
	`175`	`+ await _channel.DisposeAsync();`
`176`	`176`	`}`
`177`	`177`	`}`
`178`	`178`	`}`
Original file line number	Diff line number	Diff line change
`@@ -131,8 +131,8 @@ public async Task TestTopologyRecoveryQueueFilter()`
`131`	`131`	`{`
`132`	`132`	`await ch.CloseAsync();`
`133`	`133`	`await conn.CloseAsync();`
`134`		`- ch.Dispose();`
`135`		`- conn.Dispose();`
	`134`	`+ await ch.DisposeAsync();`
	`135`	`+ await conn.DisposeAsync();`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`
`@@ -180,8 +180,8 @@ public async Task TestTopologyRecoveryExchangeFilter()`
`180`	`180`	`{`
`181`	`181`	`await ch.CloseAsync();`
`182`	`182`	`await conn.CloseAsync();`
`183`		`- ch.Dispose();`
`184`		`- conn.Dispose();`
	`183`	`+ await ch.DisposeAsync();`
	`184`	`+ await conn.DisposeAsync();`
`185`	`185`	`}`
`186`	`186`	`}`
`187`	`187`
`@@ -237,8 +237,8 @@ public async Task TestTopologyRecoveryBindingFilter()`
`237`	`237`	`await ch.QueueDeleteAsync(queueWithIgnoredBinding);`
`238`	`238`	`await ch.CloseAsync();`
`239`	`239`	`await conn.CloseAsync();`
`240`		`- ch.Dispose();`
`241`		`- conn.Dispose();`
	`240`	`+ await ch.DisposeAsync();`
	`241`	`+ await conn.DisposeAsync();`
`242`	`242`	`}`
`243`	`243`	`}`
`244`	`244`
`@@ -325,8 +325,8 @@ public async Task TestTopologyRecoveryDefaultFilterRecoversAllEntities()`
`325`	`325`	`{`
`326`	`326`	`await ch.CloseAsync();`
`327`	`327`	`await conn.CloseAsync();`
`328`		`- ch.Dispose();`
`329`		`- conn.Dispose();`
	`328`	`+ await ch.DisposeAsync();`
	`329`	`+ await conn.DisposeAsync();`
`330`	`330`	`}`
`331`	`331`	`}`
`332`	`332`
`@@ -390,8 +390,8 @@ await _channel.QueueDeclareAsync(queueToRecoverWithException, false, false, fals`
`390`	`390`	`await _channel.QueueDeleteAsync(queueToRecoverWithException);`
`391`	`391`	`await ch.CloseAsync();`
`392`	`392`	`await conn.CloseAsync();`
`393`		`- ch.Dispose();`
`394`		`- conn.Dispose();`
	`393`	`+ await ch.DisposeAsync();`
	`394`	`+ await conn.DisposeAsync();`
`395`	`395`	`}`
`396`	`396`	`}`
`397`	`397`
`@@ -449,8 +449,8 @@ public async Task TestTopologyRecoveryExchangeExceptionHandler()`
`449`	`449`
`450`	`450`	`await ch.CloseAsync();`
`451`	`451`	`await conn.CloseAsync();`
`452`		`- ch.Dispose();`
`453`		`- conn.Dispose();`
	`452`	`+ await ch.DisposeAsync();`
	`453`	`+ await conn.DisposeAsync();`
`454`	`454`	`}`
`455`	`455`	`}`
`456`	`456`
`@@ -513,8 +513,8 @@ public async Task TestTopologyRecoveryBindingExceptionHandler()`
`513`	`513`
`514`	`514`	`await ch.CloseAsync();`
`515`	`515`	`await conn.CloseAsync();`
`516`		`- ch.Dispose();`
`517`		`- conn.Dispose();`
	`516`	`+ await ch.DisposeAsync();`
	`517`	`+ await conn.DisposeAsync();`
`518`	`518`	`}`
`519`	`519`
`520`	`520`	`[Fact]`
`@@ -590,8 +590,8 @@ public async Task TestTopologyRecoveryConsumerExceptionHandler()`
`590`	`590`	`{`
`591`	`591`	`await ch.CloseAsync();`
`592`	`592`	`await conn.CloseAsync();`
`593`		`- ch.Dispose();`
`594`		`- conn.Dispose();`
	`593`	`+ await ch.DisposeAsync();`
	`594`	`+ await conn.DisposeAsync();`
`595`	`595`	`}`
`596`	`596`	`}`
`597`	`597`	`}`
Original file line number	Diff line number	Diff line change
`@@ -116,13 +116,13 @@ public async Task DisposeAsync()`
`116`	`116`	`if (_connection != null)`
`117`	`117`	`{`
`118`	`118`	`await _connection.CloseAsync();`
	`119`	`+ await _connection.DisposeAsync();`
`119`	`120`	`}`
`120`	`121`	`}`
`121`	`122`	`finally`
`122`	`123`	`{`
`123`	`124`	`_doneEvent.Dispose();`
`124`	`125`	`_producerCredentialsProvider?.Dispose();`
`125`		`- _connection?.Dispose();`
`126`	`126`	`_cancellationTokenSource.Dispose();`
`127`	`127`	`}`
`128`	`128`	`}`
`@@ -224,7 +224,7 @@ public async Task SecondConnectionCrashes_GH1429()`
`224`	`224`	`Assert.NotNull(_connectionFactory);`
`225`	`225`	`// https://github.com/rabbitmq/rabbitmq-dotnet-client/issues/1429`
`226`	`226`	`IConnection secondConnection = await _connectionFactory.CreateConnectionAsync(CancellationToken.None);`
`227`		`- secondConnection.Dispose();`
	`227`	`+ await secondConnection.DisposeAsync();`
`228`	`228`	`}`
`229`	`229`
`230`	`230`	`private async Task<IChannel> DeclarePublishChannelAsync()`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ public async Task TestDisposeOnBlockedConnectionDoesNotHang()`
`89`	`89`	`try`
`90`	`90`	`{`
`91`	`91`	`await _conn.AbortAsync();`
`92`		`- _conn.Dispose();`
	`92`	`+ await _conn.DisposeAsync();`
`93`	`93`	`tcs.SetResult(true);`
`94`	`94`	`}`
`95`	`95`	`catch (Exception)`