diff --git a/Source/EasyNetQ.Management.Client/ManagementClient.cs b/Source/EasyNetQ.Management.Client/ManagementClient.cs
index 26fcf636..2e835a15 100644
--- a/Source/EasyNetQ.Management.Client/ManagementClient.cs
+++ b/Source/EasyNetQ.Management.Client/ManagementClient.cs
@@ -19,8 +19,6 @@ public class ManagementClient : IManagementClient
 {
     private static readonly Regex ParameterNameRegex = new("([a-z])([A-Z])", RegexOptions.Compiled);
 
-    private static Task CompletedTask { get; } = Task.FromResult<object>(null);
-
     private static readonly MediaTypeWithQualityHeaderValue JsonMediaTypeHeaderValue = new("application/json");
 
     public static readonly JsonSerializerSettings Settings;
@@ -137,12 +135,14 @@ public ManagementClient(
         httpClient.DefaultRequestHeaders.Add("Connection", "close");
     }
 
-    public Task<Overview> GetOverviewAsync(GetLengthsCriteria lengthsCriteria = null,
-        GetRatesCriteria ratesCriteria = null, CancellationToken cancellationToken = default)
+    public Task<Overview> GetOverviewAsync(
+        GetLengthsCriteria lengthsCriteria = null,
+        GetRatesCriteria ratesCriteria = null,
+        CancellationToken cancellationToken = default
+    )
     {
         var queryParameters = MergeQueryParameters(
-            lengthsCriteria?.ToQueryParameters(),
-            ratesCriteria?.ToQueryParameters()
+            lengthsCriteria?.ToQueryParameters(), ratesCriteria?.ToQueryParameters()
         );
         return GetAsync<Overview>("overview", queryParameters, cancellationToken);
     }
@@ -157,48 +157,49 @@ public Task<Definitions> GetDefinitionsAsync(CancellationToken cancellationToken
         return GetAsync<Definitions>("definitions", cancellationToken);
     }
 
-    public Task<IReadOnlyList<Connection>> GetConnectionsAsync(
-        CancellationToken cancellationToken = default)
+    public Task<IReadOnlyList<Connection>> GetConnectionsAsync(CancellationToken cancellationToken = default)
     {
         return GetAsync<IReadOnlyList<Connection>>("connections", cancellationToken);
     }
 
-    public Task CloseConnectionAsync(Connection connection,
-        CancellationToken cancellationToken = default)
+    public Task CloseConnectionAsync(Connection connection, CancellationToken cancellationToken = default)
     {
         Ensure.ArgumentNotNull(connection, nameof(connection));
         return DeleteAsync($"connections/{connection.Name}", cancellationToken);
     }
 
-    public Task<IReadOnlyList<Channel>> GetChannelsAsync(
-        CancellationToken cancellationToken = default)
+    public Task<IReadOnlyList<Channel>> GetChannelsAsync(CancellationToken cancellationToken = default)
     {
         return GetAsync<IReadOnlyList<Channel>>("channels", cancellationToken);
     }
 
-    public Task<IReadOnlyList<Channel>> GetChannelsAsync(
-        Connection connection,
-        CancellationToken cancellationToken = default)
+    public Task<IReadOnlyList<Channel>> GetChannelsAsync(Connection connection, CancellationToken cancellationToken = default)
     {
         return GetAsync<IReadOnlyList<Channel>>($"connections/{connection.Name}/channels", cancellationToken);
     }
 
-    public Task<Channel> GetChannelAsync(string channelName, GetRatesCriteria ratesCriteria = null,
-        CancellationToken cancellationToken = default)
+    public Task<Channel> GetChannelAsync(
+        string channelName,
+        GetRatesCriteria ratesCriteria = null,
+        CancellationToken cancellationToken = default
+    )
     {
         Ensure.ArgumentNotNull(channelName, nameof(channelName));
 
         return GetAsync<Channel>($"channels/{channelName}", ratesCriteria?.ToQueryParameters(), cancellationToken);
     }
 
-    public Task<IReadOnlyList<Exchange>> GetExchangesAsync(
-        CancellationToken cancellationToken = default)
+    public Task<IReadOnlyList<Exchange>> GetExchangesAsync(CancellationToken cancellationToken = default)
     {
         return GetAsync<IReadOnlyList<Exchange>>("exchanges", cancellationToken);
     }
 
-    public Task<Exchange> GetExchangeAsync(string exchangeName, Vhost vhost, GetRatesCriteria ratesCriteria = null,
-        CancellationToken cancellationToken = default)
+    public Task<Exchange> GetExchangeAsync(
+        string exchangeName,
+        Vhost vhost,
+        GetRatesCriteria ratesCriteria = null,
+        CancellationToken cancellationToken = default
+    )
     {
         Ensure.ArgumentNotNull(exchangeName, nameof(exchangeName));
         Ensure.ArgumentNotNull(vhost, nameof(vhost));
@@ -206,18 +207,25 @@ public Task<Exchange> GetExchangeAsync(string exchangeName, Vhost vhost, GetRate
         return GetAsync<Exchange>($"exchanges/{SanitiseVhostName(vhost.Name)}/{exchangeName}", ratesCriteria?.ToQueryParameters(), cancellationToken);
     }
 
-    public Task<Queue> GetQueueAsync(string queueName, Vhost vhost, GetLengthsCriteria lengthsCriteria = null,
-        GetRatesCriteria ratesCriteria = null, CancellationToken cancellationToken = default)
+    public Task<Queue> GetQueueAsync(
+        string queueName,
+        Vhost vhost,
+        GetLengthsCriteria lengthsCriteria = null,
+        GetRatesCriteria ratesCriteria = null,
+        CancellationToken cancellationToken = default
+    )
     {
         Ensure.ArgumentNotNull(queueName, nameof(queueName));
         Ensure.ArgumentNotNull(vhost, nameof(vhost));
 
         var queryParameters = MergeQueryParameters(
-            lengthsCriteria?.ToQueryParameters(),
-            ratesCriteria?.ToQueryParameters()
+            lengthsCriteria?.ToQueryParameters(), ratesCriteria?.ToQueryParameters()
+        );
+        return GetAsync<Queue>(
+            $"queues/{SanitiseVhostName(vhost.Name)}/{SanitiseName(queueName)}",
+            queryParameters,
+            cancellationToken
         );
-        return GetAsync<Queue>($"queues/{SanitiseVhostName(vhost.Name)}/{SanitiseName(queueName)}",
-            queryParameters, cancellationToken);
     }
 
     public async Task<Exchange> CreateExchangeAsync(ExchangeInfo exchangeInfo, Vhost vhost,
@@ -226,50 +234,69 @@ public async Task<Exchange> CreateExchangeAsync(ExchangeInfo exchangeInfo, Vhost
         Ensure.ArgumentNotNull(vhost, nameof(exchangeInfo));
         Ensure.ArgumentNotNull(vhost, nameof(vhost));
 
-        await PutAsync($"exchanges/{SanitiseVhostName(vhost.Name)}/{SanitiseName(exchangeInfo.GetName())}",
-            exchangeInfo, cancellationToken).ConfigureAwait(false);
+        await PutAsync
+            ($"exchanges/{SanitiseVhostName(vhost.Name)}/{SanitiseName(exchangeInfo.GetName())}",
+            exchangeInfo,
+            cancellationToken
+        ).ConfigureAwait(false);
 
-        return await GetExchangeAsync(SanitiseName(exchangeInfo.GetName()), vhost,
-            cancellationToken: cancellationToken).ConfigureAwait(false);
+        return await GetExchangeAsync(
+            SanitiseName(exchangeInfo.GetName()),
+            vhost,
+            cancellationToken: cancellationToken
+        ).ConfigureAwait(false);
     }
 
-    public Task DeleteExchangeAsync(Exchange exchange,
-        CancellationToken cancellationToken = default)
+    public Task DeleteExchangeAsync(Exchange exchange, CancellationToken cancellationToken = default)
     {
         Ensure.ArgumentNotNull(exchange, nameof(exchange));
 
-        return DeleteAsync($"exchanges/{SanitiseVhostName(exchange.Vhost)}/{SanitiseName(exchange.Name)}",
-            cancellationToken);
+        return DeleteAsync(
+            $"exchanges/{SanitiseVhostName(exchange.Vhost)}/{SanitiseName(exchange.Name)}",
+            cancellationToken
+        );
     }
 
-    public Task<IReadOnlyList<Binding>> GetBindingsWithSourceAsync(Exchange exchange,
-        CancellationToken cancellationToken = default)
+    public Task<IReadOnlyList<Binding>> GetBindingsWithSourceAsync(
+        Exchange exchange,
+        CancellationToken cancellationToken = default
+    )
     {
         Ensure.ArgumentNotNull(exchange, nameof(exchange));
 
         return GetAsync<IReadOnlyList<Binding>>(
-            $"exchanges/{SanitiseVhostName(exchange.Vhost)}/{exchange.Name}/bindings/source", cancellationToken);
+            $"exchanges/{SanitiseVhostName(exchange.Vhost)}/{exchange.Name}/bindings/source",
+            cancellationToken
+        );
     }
 
-    public Task<IReadOnlyList<Binding>> GetBindingsWithDestinationAsync(Exchange exchange,
-        CancellationToken cancellationToken = default)
+    public Task<IReadOnlyList<Binding>> GetBindingsWithDestinationAsync(
+        Exchange exchange,
+        CancellationToken cancellationToken = default
+    )
     {
         Ensure.ArgumentNotNull(exchange, nameof(exchange));
 
         return GetAsync<IReadOnlyList<Binding>>(
             $"exchanges/{SanitiseVhostName(exchange.Vhost)}/{exchange.Name}/bindings/destination",
-            cancellationToken);
+            cancellationToken
+        );
     }
 
-    public Task<PublishResult> PublishAsync(Exchange exchange, PublishInfo publishInfo,
-        CancellationToken cancellationToken = default)
+    public Task<PublishResult> PublishAsync(
+        Exchange exchange,
+        PublishInfo publishInfo,
+        CancellationToken cancellationToken = default
+    )
     {
         Ensure.ArgumentNotNull(exchange, nameof(exchange));
         Ensure.ArgumentNotNull(publishInfo, nameof(publishInfo));
 
         return PostAsync<PublishInfo, PublishResult>(
-            $"exchanges/{SanitiseVhostName(exchange.Vhost)}/{exchange.Name}/publish", publishInfo,
-            cancellationToken);
+            $"exchanges/{SanitiseVhostName(exchange.Vhost)}/{exchange.Name}/publish",
+            publishInfo,
+            cancellationToken
+        );
     }
 
     public Task<IReadOnlyList<Queue>> GetQueuesAsync(CancellationToken cancellationToken = default)
@@ -295,49 +322,59 @@ await PutAsync($"queues/{SanitiseVhostName(vhost.Name)}/{SanitiseName(queueInfo.
             .ConfigureAwait(false);
     }
 
-    public Task DeleteQueueAsync(Queue queue,
-        CancellationToken cancellationToken = default)
+    public Task DeleteQueueAsync(Queue queue, CancellationToken cancellationToken = default)
     {
         Ensure.ArgumentNotNull(queue, nameof(queue));
 
-        return DeleteAsync($"queues/{SanitiseVhostName(queue.Vhost)}/{SanitiseName(queue.Name)}",
-            cancellationToken);
+        return DeleteAsync(
+            $"queues/{SanitiseVhostName(queue.Vhost)}/{SanitiseName(queue.Name)}", cancellationToken
+        );
     }
 
-    public Task<IReadOnlyList<Binding>> GetBindingsForQueueAsync(Queue queue,
-        CancellationToken cancellationToken = default)
+    public Task<IReadOnlyList<Binding>> GetBindingsForQueueAsync(Queue queue, CancellationToken cancellationToken = default)
     {
         Ensure.ArgumentNotNull(queue, nameof(queue));
 
         return GetAsync<IReadOnlyList<Binding>>(
-            $"queues/{SanitiseVhostName(queue.Vhost)}/{SanitiseName(queue.Name)}/bindings", cancellationToken);
+            $"queues/{SanitiseVhostName(queue.Vhost)}/{SanitiseName(queue.Name)}/bindings", cancellationToken
+        );
     }
 
     public Task PurgeAsync(Queue queue, CancellationToken cancellationToken = default)
     {
         Ensure.ArgumentNotNull(queue, nameof(queue));
 
-        return DeleteAsync($"queues/{SanitiseVhostName(queue.Vhost)}/{SanitiseName(queue.Name)}/contents",
-            cancellationToken);
+        return DeleteAsync(
+            $"queues/{SanitiseVhostName(queue.Vhost)}/{SanitiseName(queue.Name)}/contents", cancellationToken
+        );
     }
 
-    public Task<IReadOnlyList<Message>> GetMessagesFromQueueAsync(Queue queue, GetMessagesCriteria criteria,
-        CancellationToken cancellationToken = default)
+    public Task<IReadOnlyList<Message>> GetMessagesFromQueueAsync(
+        Queue queue,
+        GetMessagesCriteria criteria,
+        CancellationToken cancellationToken = default
+    )
     {
         Ensure.ArgumentNotNull(queue, nameof(queue));
 
         return PostAsync<GetMessagesCriteria, IReadOnlyList<Message>>(
-            $"queues/{SanitiseVhostName(queue.Vhost)}/{SanitiseName(queue.Name)}/get", criteria, cancellationToken);
+            $"queues/{SanitiseVhostName(queue.Vhost)}/{SanitiseName(queue.Name)}/get",
+            criteria,
+            cancellationToken
+        );
     }
 
-    public Task<IReadOnlyList<Binding>> GetBindingsAsync(
-        CancellationToken cancellationToken = default)
+    public Task<IReadOnlyList<Binding>> GetBindingsAsync(CancellationToken cancellationToken = default)
     {
         return GetAsync<IReadOnlyList<Binding>>("bindings", cancellationToken);
     }
 
-    public Task CreateBindingAsync(Exchange exchange, Queue queue, BindingInfo bindingInfo,
-        CancellationToken cancellationToken = default)
+    public Task CreateBindingAsync(
+        Exchange exchange,
+        Queue queue,
+        BindingInfo bindingInfo,
+        CancellationToken cancellationToken = default
+    )
     {
         Ensure.ArgumentNotNull(exchange, nameof(exchange));
         Ensure.ArgumentNotNull(queue, nameof(queue));
@@ -345,11 +382,17 @@ public Task CreateBindingAsync(Exchange exchange, Queue queue, BindingInfo bindi
 
         return PostAsync<BindingInfo, object>(
             $"bindings/{SanitiseVhostName(queue.Vhost)}/e/{exchange.Name}/q/{SanitiseName(queue.Name)}",
-            bindingInfo, cancellationToken);
+            bindingInfo,
+            cancellationToken
+        );
     }
 
-    public Task CreateBindingAsync(Exchange sourceExchange, Exchange destinationExchange, BindingInfo bindingInfo,
-        CancellationToken cancellationToken = default)
+    public Task CreateBindingAsync(
+        Exchange sourceExchange,
+        Exchange destinationExchange,
+        BindingInfo bindingInfo,
+        CancellationToken cancellationToken = default
+    )
     {
         Ensure.ArgumentNotNull(sourceExchange, nameof(sourceExchange));
         Ensure.ArgumentNotNull(destinationExchange, nameof(destinationExchange));
@@ -357,33 +400,42 @@ public Task CreateBindingAsync(Exchange sourceExchange, Exchange destinationExch
 
         return PostAsync<BindingInfo, object>(
             $"bindings/{SanitiseVhostName(sourceExchange.Vhost)}/e/{sourceExchange.Name}/e/{destinationExchange.Name}",
-            bindingInfo, cancellationToken);
+            bindingInfo,
+            cancellationToken
+        );
     }
 
-    public Task<IReadOnlyList<Binding>> GetBindingsAsync(Exchange exchange, Queue queue,
-        CancellationToken cancellationToken = default)
+    public Task<IReadOnlyList<Binding>> GetBindingsAsync(
+        Exchange exchange,
+        Queue queue,
+        CancellationToken cancellationToken = default
+    )
     {
         Ensure.ArgumentNotNull(exchange, nameof(exchange));
         Ensure.ArgumentNotNull(queue, nameof(queue));
 
         return GetAsync<IReadOnlyList<Binding>>(
             $"bindings/{SanitiseVhostName(queue.Vhost)}/e/{exchange.Name}/q/{SanitiseName(queue.Name)}",
-            cancellationToken);
+            cancellationToken
+        );
     }
 
-    public Task<IReadOnlyList<Binding>> GetBindingsAsync(Exchange fromExchange, Exchange toExchange,
-        CancellationToken cancellationToken = default)
+    public Task<IReadOnlyList<Binding>> GetBindingsAsync(
+        Exchange fromExchange,
+        Exchange toExchange,
+        CancellationToken cancellationToken = default
+    )
     {
         Ensure.ArgumentNotNull(fromExchange, nameof(fromExchange));
         Ensure.ArgumentNotNull(toExchange, nameof(toExchange));
 
         return GetAsync<IReadOnlyList<Binding>>(
             $"bindings/{SanitiseVhostName(toExchange.Vhost)}/e/{fromExchange.Name}/e/{SanitiseName(toExchange.Name)}",
-            cancellationToken);
+            cancellationToken
+        );
     }
 
-    public Task DeleteBindingAsync(Binding binding,
-        CancellationToken cancellationToken = default)
+    public Task DeleteBindingAsync(Binding binding, CancellationToken cancellationToken = default)
     {
         Ensure.ArgumentNotNull(binding, nameof(binding));
 
@@ -402,12 +454,17 @@ public Task DeleteBindingAsync(Binding binding,
             throw new ArgumentException("Empty binding destination type isn't supported.");
         }
 
-        return DeleteAsync(string.Format("bindings/{0}/e/{1}/{2}/{3}/{4}",
-            SanitiseVhostName(binding.Vhost),
-            binding.Source,
-            binding.DestinationType[0], // e for exchange or q for queue
-            binding.Destination,
-            RecodeBindingPropertiesKey(binding.PropertiesKey)), cancellationToken);
+        return DeleteAsync(
+            string.Format(
+                "bindings/{0}/e/{1}/{2}/{3}/{4}",
+                SanitiseVhostName(binding.Vhost),
+                binding.Source,
+                binding.DestinationType[0], // e for exchange or q for queue
+                binding.Destination,
+                RecodeBindingPropertiesKey(binding.PropertiesKey)
+            ),
+            cancellationToken
+        );
     }
 
     public Task<IReadOnlyList<Vhost>> GetVhostsAsync(CancellationToken cancellationToken = default)
@@ -415,14 +472,12 @@ public Task<IReadOnlyList<Vhost>> GetVhostsAsync(CancellationToken cancellationT
         return GetAsync<IReadOnlyList<Vhost>>("vhosts", cancellationToken);
     }
 
-    public Task<Vhost> GetVhostAsync(string vhostName,
-        CancellationToken cancellationToken = default)
+    public Task<Vhost> GetVhostAsync(string vhostName, CancellationToken cancellationToken = default)
     {
         return GetAsync<Vhost>($"vhosts/{SanitiseVhostName(vhostName)}", cancellationToken);
     }
 
-    public async Task<Vhost> CreateVhostAsync(string vhostName,
-        CancellationToken cancellationToken = default)
+    public async Task<Vhost> CreateVhostAsync(string vhostName, CancellationToken cancellationToken = default)
     {
         Ensure.ArgumentNotNull(vhostName, nameof(vhostName));
 
@@ -431,28 +486,25 @@ await PutAsync<string>($"vhosts/{SanitiseVhostName(vhostName)}", cancellationTok
         return await GetVhostAsync(vhostName, cancellationToken).ConfigureAwait(false);
     }
 
-    public Task DeleteVhostAsync(Vhost vhost,
-        CancellationToken cancellationToken = default)
+    public Task DeleteVhostAsync(Vhost vhost, CancellationToken cancellationToken = default)
     {
         Ensure.ArgumentNotNull(vhost, nameof(vhost));
 
         return DeleteAsync($"vhosts/{SanitiseVhostName(vhost.Name)}", cancellationToken);
     }
 
-    public Task EnableTracingAsync(Vhost vhost,
-        CancellationToken cancellationToken = default)
+    public Task EnableTracingAsync(Vhost vhost, CancellationToken cancellationToken = default)
     {
         Ensure.ArgumentNotNull(vhost, nameof(vhost));
         vhost.Tracing = true;
-        return PutAsync<Vhost>($"vhosts/{SanitiseVhostName(vhost.Name)}", vhost, cancellationToken);
+        return PutAsync($"vhosts/{SanitiseVhostName(vhost.Name)}", vhost, cancellationToken);
     }
 
-    public Task DisableTracingAsync(Vhost vhost,
-        CancellationToken cancellationToken = default)
+    public Task DisableTracingAsync(Vhost vhost, CancellationToken cancellationToken = default)
     {
         Ensure.ArgumentNotNull(vhost, nameof(vhost));
         vhost.Tracing = false;
-        return PutAsync<Vhost>($"vhosts/{SanitiseVhostName(vhost.Name)}", vhost, cancellationToken);
+        return PutAsync($"vhosts/{SanitiseVhostName(vhost.Name)}", vhost, cancellationToken);
     }
 
     public Task<IReadOnlyList<User>> GetUsersAsync(CancellationToken cancellationToken = default)
@@ -460,15 +512,13 @@ public Task<IReadOnlyList<User>> GetUsersAsync(CancellationToken cancellationTok
         return GetAsync<IReadOnlyList<User>>("users", cancellationToken);
     }
 
-    public Task<User> GetUserAsync(string userName,
-        CancellationToken cancellationToken = default)
+    public Task<User> GetUserAsync(string userName, CancellationToken cancellationToken = default)
     {
         Ensure.ArgumentNotNull(userName, nameof(userName));
         return GetAsync<User>($"users/{userName}", cancellationToken);
     }
 
-    public Task<IReadOnlyList<Policy>> GetPoliciesAsync(
-        CancellationToken cancellationToken = default)
+    public Task<IReadOnlyList<Policy>> GetPoliciesAsync(CancellationToken cancellationToken = default)
     {
         return GetAsync<IReadOnlyList<Policy>>("policies", cancellationToken);
     }
@@ -494,8 +544,7 @@ public Task CreatePolicyAsync(Policy policy, CancellationToken cancellationToken
         return PutAsync(GetPolicyUrl(policy.Name, policy.Vhost), policy, cancellationToken);
     }
 
-    public Task DeletePolicyAsync(string policyName, Vhost vhost,
-        CancellationToken cancellationToken = default)
+    public Task DeletePolicyAsync(string policyName, Vhost vhost, CancellationToken cancellationToken = default)
     {
         Ensure.ArgumentNotNull(policyName, nameof(policyName));
         Ensure.ArgumentNotNull(vhost, nameof(vhost));
@@ -503,8 +552,7 @@ public Task DeletePolicyAsync(string policyName, Vhost vhost,
         return DeleteAsync(GetPolicyUrl(policyName, vhost.Name), cancellationToken);
     }
 
-    public Task<IReadOnlyList<Parameter>> GetParametersAsync(
-        CancellationToken cancellationToken = default)
+    public Task<IReadOnlyList<Parameter>> GetParametersAsync(CancellationToken cancellationToken = default)
     {
         return GetAsync<IReadOnlyList<Parameter>>("parameters", cancellationToken);
     }
@@ -513,12 +561,20 @@ public Task CreateParameterAsync(Parameter parameter,
         CancellationToken cancellationToken = default)
     {
         Ensure.ArgumentNotNull(parameter, nameof(parameter));
-        return PutAsync(GetParameterUrl(parameter.Component, parameter.Vhost, parameter.Name), parameter.Value,
-            cancellationToken);
+
+        return PutAsync(
+            GetParameterUrl(parameter.Component, parameter.Vhost, parameter.Name),
+            parameter.Value,
+            cancellationToken
+        );
     }
 
-    public Task DeleteParameterAsync(string componentName, string vhost, string name,
-        CancellationToken cancellationToken = default)
+    public Task DeleteParameterAsync(
+        string componentName,
+        string vhost,
+        string name,
+        CancellationToken cancellationToken = default
+    )
     {
         Ensure.ArgumentNotNull(componentName, nameof(componentName));
         Ensure.ArgumentNotNull(vhost, nameof(vhost));
@@ -527,8 +583,7 @@ public Task DeleteParameterAsync(string componentName, string vhost, string name
         return DeleteAsync(GetParameterUrl(componentName, vhost, name), cancellationToken);
     }
 
-    public async Task<User> CreateUserAsync(UserInfo userInfo,
-        CancellationToken cancellationToken = default)
+    public async Task<User> CreateUserAsync(UserInfo userInfo, CancellationToken cancellationToken = default)
     {
         Ensure.ArgumentNotNull(userInfo, nameof(userInfo));
 
@@ -544,44 +599,42 @@ public Task DeleteUserAsync(User user, CancellationToken cancellationToken = def
         return DeleteAsync($"users/{user.Name}", cancellationToken);
     }
 
-    public Task<IReadOnlyList<Permission>> GetPermissionsAsync(
-        CancellationToken cancellationToken = default)
+    public Task<IReadOnlyList<Permission>> GetPermissionsAsync(CancellationToken cancellationToken = default)
     {
         return GetAsync<IReadOnlyList<Permission>>("permissions", cancellationToken);
     }
 
-    public Task CreatePermissionAsync(PermissionInfo permissionInfo,
-        CancellationToken cancellationToken = default)
+    public Task CreatePermissionAsync(PermissionInfo permissionInfo, CancellationToken cancellationToken = default)
     {
         Ensure.ArgumentNotNull(permissionInfo, nameof(permissionInfo));
 
         return PutAsync(
             $"permissions/{SanitiseVhostName(permissionInfo.GetVirtualHostName())}/{permissionInfo.GetUserName()}",
-            permissionInfo, cancellationToken);
+            permissionInfo,
+            cancellationToken
+        );
     }
 
-    public Task DeletePermissionAsync(Permission permission,
-        CancellationToken cancellationToken = default)
+    public Task DeletePermissionAsync(Permission permission, CancellationToken cancellationToken = default)
     {
         Ensure.ArgumentNotNull(permission, nameof(permission));
 
         return DeleteAsync($"permissions/{permission.Vhost}/{permission.User}", cancellationToken);
     }
 
-    public Task<IReadOnlyList<TopicPermission>> GetTopicPermissionsAsync(
-        CancellationToken cancellationToken = default)
+    public Task<IReadOnlyList<TopicPermission>> GetTopicPermissionsAsync(CancellationToken cancellationToken = default)
     {
         return GetAsync<IReadOnlyList<TopicPermission>>("topic-permissions", cancellationToken);
     }
 
-    public Task CreateTopicPermissionAsync(TopicPermissionInfo topicPermissionInfo,
-        CancellationToken cancellationToken = default)
+    public Task CreateTopicPermissionAsync(TopicPermissionInfo topicPermissionInfo, CancellationToken cancellationToken = default)
     {
         Ensure.ArgumentNotNull(topicPermissionInfo, nameof(topicPermissionInfo));
 
         return PutAsync(
             $"topic-permissions/{SanitiseVhostName(topicPermissionInfo.GetVirtualHostName())}/{topicPermissionInfo.GetUserName()}",
-            topicPermissionInfo, cancellationToken);
+            topicPermissionInfo, cancellationToken
+        );
     }
 
     public Task DeleteTopicPermissionAsync(TopicPermission topicPermission,
@@ -608,8 +661,7 @@ public async Task<User> ChangeUserPasswordAsync(string userName, string newPassw
         return await CreateUserAsync(userInfo, cancellationToken).ConfigureAwait(false);
     }
 
-    public Task<List<Federation>> GetFederationAsync(
-        CancellationToken cancellationToken = default)
+    public Task<List<Federation>> GetFederationAsync(CancellationToken cancellationToken = default)
     {
         return GetAsync<List<Federation>>("federation-links", cancellationToken);
     }
@@ -619,134 +671,89 @@ public async Task<bool> IsAliveAsync(Vhost vhost,
     {
         Ensure.ArgumentNotNull(vhost, nameof(vhost));
 
-        var result = await GetAsync<AlivenessTestResult>($"aliveness-test/{SanitiseVhostName(vhost.Name)}",
-            cancellationToken).ConfigureAwait(false);
+        var result = await GetAsync<AlivenessTestResult>(
+            $"aliveness-test/{SanitiseVhostName(vhost.Name)}", cancellationToken
+        ).ConfigureAwait(false);
         return result.Status == "ok";
     }
 
-    private Task<T> GetAsync<T>(
-        string path,
-        CancellationToken cancellationToken = default)
+    private Task<T> GetAsync<T>(string path, CancellationToken cancellationToken = default)
     {
         return GetAsync<T>(path, null, cancellationToken);
     }
 
 
-    private Task<T> GetAsync<T>(
+    private async Task<T> GetAsync<T>(
         string path,
         IReadOnlyDictionary<string, string> queryParameters,
-        CancellationToken cancellationToken = default)
+        CancellationToken cancellationToken = default
+    )
     {
-        var request = CreateRequestForPath(HttpMethod.Get, path, BuildQueryString(queryParameters));
-        return httpClient.SendAsync(request, cancellationToken)
-            .ContinueWithOrThrow(_ => AnalyseResponse<T>(code => code == HttpStatusCode.OK, _.Result), cancellationToken)
-            .ContinueWith(__ =>
-            {
-                request?.Dispose();
-                return __;
-            }, cancellationToken).Unwrap();
+        using var request = CreateRequestForPath(HttpMethod.Get, path, BuildQueryString(queryParameters));
+        using var response = await httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
+
+        return await DeserializeResponseAsync<T>(c => c == HttpStatusCode.OK, response).ConfigureAwait(false);
     }
 
-    private Task<TResult> PostAsync<TItem, TResult>(
+    private async Task<TResult> PostAsync<TItem, TResult>(
         string path,
         TItem item,
-        CancellationToken cancellationToken = default)
+        CancellationToken cancellationToken = default
+    )
     {
-        var request = CreateRequestForPath(HttpMethod.Post, path, string.Empty);
+        using var request = CreateRequestForPath(HttpMethod.Post, path, string.Empty);
 
         InsertRequestBody(request, item);
 
-        return httpClient.SendAsync(request, cancellationToken)
-            .ContinueWithOrThrow(_ =>
-            {
-                bool Success(HttpStatusCode statusCode) =>
-                    statusCode == HttpStatusCode.OK ||
-                    statusCode == HttpStatusCode.Created;
+        using var response = await httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
 
-                return AnalyseResponse<TResult>(Success, _.Result)
-                    .ContinueWith(__ =>
-                    {
-                        request?.Dispose();
-                        return __;
-                    }, cancellationToken);
-            }, cancellationToken).Unwrap();
+        return await DeserializeResponseAsync<TResult>(
+            c => c is HttpStatusCode.OK or HttpStatusCode.Created, response
+        ).ConfigureAwait(false);
     }
 
-    private Task DeleteAsync(
+    private async Task DeleteAsync(
         string path,
-        CancellationToken cancellationToken = default)
+        CancellationToken cancellationToken = default
+    )
     {
-        var request = CreateRequestForPath(HttpMethod.Delete, path, string.Empty);
+        using var request = CreateRequestForPath(HttpMethod.Delete, path, string.Empty);
+        using var response = await httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
 
-        return httpClient.SendAsync(request, cancellationToken)
-            .ContinueWithOrThrow(_ =>
-                    AnalyseResponse(statusCode => statusCode == HttpStatusCode.NoContent, _.Result)
-                        .ContinueWith(__ =>
-                        {
-                            request?.Dispose();
-                            return __;
-                        }, cancellationToken).Unwrap()
-                , cancellationToken);
+        await DeserializeResponseAsync(c => c == HttpStatusCode.NoContent, response).ConfigureAwait(false);
     }
 
-    private Task PutAsync<T>(
+    private async Task PutAsync<T>(
         string path,
         T item = default,
-        CancellationToken cancellationToken = default) where T : class
+        CancellationToken cancellationToken = default
+    ) where T : class
     {
-        var request = CreateRequestForPath(HttpMethod.Put, path, string.Empty);
+        using var request = CreateRequestForPath(HttpMethod.Put, path, string.Empty);
 
-        if (item != default(T))
-            InsertRequestBody(request, item);
+        if (item != null) InsertRequestBody(request, item);
 
-        return httpClient.SendAsync(request, cancellationToken)
-            .ContinueWithOrThrow(_ =>
-            {
-                bool ResponseSucceeded(HttpStatusCode statusCode) => statusCode == HttpStatusCode.OK ||
-                                                                     statusCode == HttpStatusCode.Created ||
-                                                                     statusCode == HttpStatusCode.NoContent;
+        using var response = await httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
 
-                return AnalyseResponse(ResponseSucceeded, _.Result)
-                    .ContinueWith(__ =>
-                    {
-                        request?.Dispose();
-                        return __;
-                    }, cancellationToken).Unwrap();
-            }, cancellationToken);
+        await DeserializeResponseAsync(
+            s => s is HttpStatusCode.OK or HttpStatusCode.Created or HttpStatusCode.NoContent, response
+        ).ConfigureAwait(false);
     }
 
-    private static Task AnalyseResponse(
-        Func<HttpStatusCode, bool> success,
-        HttpResponseMessage responseMessage)
+    private static Task DeserializeResponseAsync(Func<HttpStatusCode, bool> success, HttpResponseMessage response)
     {
-        var httpStatusCode = responseMessage.StatusCode;
-        try
-        {
-            if (success(httpStatusCode))
-                return CompletedTask;
-            throw new UnexpectedHttpStatusCodeException(httpStatusCode);
-        }
-        finally
-        {
-            responseMessage.Dispose();
-        }
+        return success(response.StatusCode)
+            ? Task.CompletedTask
+            : Task.FromException(new UnexpectedHttpStatusCodeException(response.StatusCode));
     }
 
-    private static Task<T> AnalyseResponse<T>(
-        Func<HttpStatusCode, bool> success,
-        HttpResponseMessage responseMessage)
+    private static async Task<T> DeserializeResponseAsync<T>(Func<HttpStatusCode, bool> success, HttpResponseMessage response)
     {
-        var httpStatusCode = responseMessage.StatusCode;
-        try
-        {
-            if (success(httpStatusCode))
-                return DeserializeResponseAsync<T>(responseMessage);
-            throw new UnexpectedHttpStatusCodeException(httpStatusCode);
-        }
-        finally
-        {
-            responseMessage.Dispose();
-        }
+        if (!success(response.StatusCode))
+            throw new UnexpectedHttpStatusCodeException(response.StatusCode);
+
+        var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+        return JsonConvert.DeserializeObject<T>(content, Settings);
     }
 
     private static void InsertRequestBody<T>(HttpRequestMessage request, T item)
@@ -771,12 +778,6 @@ private static string GetParameterUrl(string componentName, string vhost, string
         return $"parameters/{componentName}/{SanitiseVhostName(vhost)}/{parameterName}";
     }
 
-    private static Task<T> DeserializeResponseAsync<T>(HttpResponseMessage response)
-    {
-        return response.Content.ReadAsStringAsync()
-            .ContinueWith(_ => JsonConvert.DeserializeObject<T>(_.Result, Settings));
-    }
-
     private HttpRequestMessage CreateRequestForPath(HttpMethod httpMethod, string path, string query)
     {
         var uri = new Uri($"{HostUrl}:{PortNumber}/api/{path}{query ?? string.Empty}");
diff --git a/Source/EasyNetQ.Management.Client/TaskExtensions.cs b/Source/EasyNetQ.Management.Client/TaskExtensions.cs
deleted file mode 100644
index ad375cc8..00000000
--- a/Source/EasyNetQ.Management.Client/TaskExtensions.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace EasyNetQ.Management.Client;
-
-internal static class TaskExtensions
-{
-    public static Task<TNewResult> ContinueWithOrThrow<TNewResult, TResult>(this Task<TResult> task, Func<Task<TResult>, Task<TNewResult>> func, CancellationToken cancellationToken)
-    {
-        if (task == null) throw new ArgumentNullException(nameof(task));
-        if (task.Exception != null)
-            throw task.Exception.GetBaseException();
-        return task.ContinueWith(func, cancellationToken).Unwrap();
-    }
-
-    public static Task ContinueWithOrThrow<TResult>(this Task<TResult> task, Func<Task<TResult>, Task> func, CancellationToken cancellationToken)
-    {
-        if (task == null) throw new ArgumentNullException(nameof(task));
-        if (task.Exception != null)
-            throw task.Exception.GetBaseException();
-        return task.ContinueWith(func, cancellationToken).Unwrap();
-    }
-}