Follow-up to #1669 - per-channel dispatch concurrency

lukebakken · lukebakken · commit b9797d4d7f44 · 2024-09-11T17:13:14.000-07:00
PR #1669 by @danielmarbach adds the ability to configure consumer dispatch on a per-channel basis. * Test that consumer dispatch concurrency is set on the dispatcher.
diff --git a/projects/Benchmarks/Networking/Networking_BasicDeliver_Commons.cs b/projects/Benchmarks/Networking/Networking_BasicDeliver_Commons.cs
@@ -9,9 +9,10 @@ namespace Benchmarks.Networking
     [MemoryDiagnoser]
     public class Networking_BasicDeliver_Commons
     {
-        public static async Task Publish_Hello_World(IConnection connection, uint messageCount, byte[] body)
+        public static async Task Publish_Hello_World(IConnection connection,
+            uint messageCount, byte[] body, ushort consumerDispatchConcurrency = 1)
         {
-            using (IChannel channel = await connection.CreateChannelAsync())
+            using (IChannel channel = await connection.CreateChannelAsync(consumerDispatchConcurrency))
             {
                 QueueDeclareOk queue = await channel.QueueDeclareAsync();
                 var consumer = new CountingConsumer(channel, messageCount);
diff --git a/projects/Benchmarks/Networking/Networking_BasicDeliver_ConnectionChurn.cs b/projects/Benchmarks/Networking/Networking_BasicDeliver_ConnectionChurn.cs
@@ -29,16 +29,17 @@ public void GlobalCleanup()
         [Benchmark(Baseline = true)]
         public async Task Publish_Hello_World()
         {
-            var cf = new ConnectionFactory { ConsumerDispatchConcurrency = 2 };
+            var cf = new ConnectionFactory();
             using (IConnection connection = await cf.CreateConnectionAsync())
             {
-                await Publish_Hello_World(connection);
+                await Publish_Hello_World(connection, 2);
             }
         }
 
-        public static async Task Publish_Hello_World(IConnection connection)
+        public static async Task Publish_Hello_World(IConnection connection, ushort consumerDispatchConcurrency)
         {
-            await Networking_BasicDeliver_Commons.Publish_Hello_World(connection, messageCount, _body);
+            await Networking_BasicDeliver_Commons.Publish_Hello_World(connection, messageCount, _body,
+                consumerDispatchConcurrency);
         }
     }
 }
diff --git a/projects/Benchmarks/Networking/Networking_BasicDeliver_LongLivedConnection.cs b/projects/Benchmarks/Networking/Networking_BasicDeliver_LongLivedConnection.cs
@@ -19,8 +19,7 @@ public class Networking_BasicDeliver_LongLivedConnection
         public void GlobalSetup()
         {
             _container = RabbitMQBroker.Start();
-
-            var cf = new ConnectionFactory { ConsumerDispatchConcurrency = 2 };
+            var cf = new ConnectionFactory();
             // NOTE: https://github.com/dotnet/BenchmarkDotNet/issues/1738
             _connection = EnsureCompleted(cf.CreateConnectionAsync());
         }
@@ -35,7 +34,8 @@ public void GlobalCleanup()
         [Benchmark(Baseline = true)]
         public Task Publish_Hello_World()
         {
-            return Networking_BasicDeliver_Commons.Publish_Hello_World(_connection, messageCount, _body);
+            return Networking_BasicDeliver_Commons.Publish_Hello_World(_connection, messageCount, _body,
+                consumerDispatchConcurrency: 2);
         }
 
         private static T EnsureCompleted<T>(Task<T> task) => task.GetAwaiter().GetResult();
diff --git a/projects/RabbitMQ.Client/PublicAPI.Shipped.txt b/projects/RabbitMQ.Client/PublicAPI.Shipped.txt
@@ -700,6 +700,7 @@ readonly RabbitMQ.Client.ConnectionConfig.AuthMechanisms -> System.Collections.G
 readonly RabbitMQ.Client.ConnectionConfig.ClientProperties -> System.Collections.Generic.IDictionary<string, object>
 readonly RabbitMQ.Client.ConnectionConfig.ClientProvidedName -> string
 readonly RabbitMQ.Client.ConnectionConfig.ContinuationTimeout -> System.TimeSpan
+readonly RabbitMQ.Client.ConnectionConfig.ConsumerDispatchConcurrency -> ushort
 readonly RabbitMQ.Client.ConnectionConfig.HandshakeContinuationTimeout -> System.TimeSpan
 readonly RabbitMQ.Client.ConnectionConfig.HeartbeatInterval -> System.TimeSpan
 readonly RabbitMQ.Client.ConnectionConfig.MaxChannelCount -> ushort
@@ -891,8 +892,6 @@ static RabbitMQ.Client.IChannelExtensions.BasicPublishAsync(this RabbitMQ.Client
 static RabbitMQ.Client.IChannelExtensions.BasicPublishAsync(this RabbitMQ.Client.IChannel! channel, RabbitMQ.Client.CachedString! exchange, RabbitMQ.Client.CachedString! routingKey, System.ReadOnlyMemory<byte> body, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask
 static RabbitMQ.Client.IChannelExtensions.BasicPublishAsync(this RabbitMQ.Client.IChannel! channel, string! exchange, string! routingKey, bool mandatory, System.ReadOnlyMemory<byte> body, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask
 static RabbitMQ.Client.IChannelExtensions.BasicPublishAsync(this RabbitMQ.Client.IChannel! channel, string! exchange, string! routingKey, System.ReadOnlyMemory<byte> body, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask
+const RabbitMQ.Client.Constants.DefaultConsumerDispatchConcurrency = 1 -> ushort
 RabbitMQ.Client.IChannel.ConfirmSelectAsync(bool trackConfirmations = true, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!
-const RabbitMQ.Client.ConnectionFactory.DefaultConsumerDispatchConcurrency = 1 -> ushort
-RabbitMQ.Client.IConnection.CreateChannelAsync(ushort consumerDispatchConcurrency, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<RabbitMQ.Client.IChannel!>!
-static RabbitMQ.Client.IConnectionExtensions.CreateChannelAsync(this RabbitMQ.Client.IConnection! connection, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<RabbitMQ.Client.IChannel!>!
-readonly RabbitMQ.Client.ConnectionConfig.ConsumerDispatchConcurrency -> ushort
+RabbitMQ.Client.IConnection.CreateChannelAsync(ushort consumerDispatchConcurrency = 1, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<RabbitMQ.Client.IChannel!>!
diff --git a/projects/RabbitMQ.Client/client/api/ConnectionConfig.cs b/projects/RabbitMQ.Client/client/api/ConnectionConfig.cs
@@ -150,7 +150,8 @@ internal ConnectionConfig(string virtualHost, string userName, string password,
             ushort maxChannelCount, uint maxFrameSize, uint maxInboundMessageBodySize, bool topologyRecoveryEnabled,
             TopologyRecoveryFilter topologyRecoveryFilter, TopologyRecoveryExceptionHandler topologyRecoveryExceptionHandler,
             TimeSpan networkRecoveryInterval, TimeSpan heartbeatInterval, TimeSpan continuationTimeout, TimeSpan handshakeContinuationTimeout, TimeSpan requestedConnectionTimeout,
-            ushort consumerDispatchConcurrency, Func<AmqpTcpEndpoint, CancellationToken, Task<IFrameHandler>> frameHandlerFactoryAsync)
+            ushort consumerDispatchConcurrency,
+            Func<AmqpTcpEndpoint, CancellationToken, Task<IFrameHandler>> frameHandlerFactoryAsync)
         {
             VirtualHost = virtualHost;
             UserName = userName;
diff --git a/projects/RabbitMQ.Client/client/api/ConnectionFactory.cs b/projects/RabbitMQ.Client/client/api/ConnectionFactory.cs
@@ -92,11 +92,6 @@ namespace RabbitMQ.Client
     ///hosts with an empty name are not addressable. </para></remarks>
     public sealed class ConnectionFactory : ConnectionFactoryBase, IConnectionFactory
     {
-        /// <summary>
-        /// Default value for consumer dispatch concurrency.
-        /// </summary>
-        public const ushort DefaultConsumerDispatchConcurrency = 1;
-
         /// <summary>
         /// Default value for the desired maximum channel number. Default: 2047.
         /// </summary>
@@ -180,7 +175,8 @@ public sealed class ConnectionFactory : ConnectionFactoryBase, IConnectionFactor
         /// </summary>
         /// <remarks>For concurrency greater than one this removes the guarantee that consumers handle messages in the order they receive them.
         /// In addition to that consumers need to be thread/concurrency safe.</remarks>
-        public ushort ConsumerDispatchConcurrency { get; set; } = DefaultConsumerDispatchConcurrency;
+        public ushort ConsumerDispatchConcurrency { get; set; } = Constants.DefaultConsumerDispatchConcurrency;
+
 
         /// <summary>The host to connect to.</summary>
         public string HostName { get; set; } = "localhost";
diff --git a/projects/RabbitMQ.Client/client/api/IConnection.cs b/projects/RabbitMQ.Client/client/api/IConnection.cs
@@ -239,12 +239,13 @@ Task CloseAsync(ushort reasonCode, string reasonText, TimeSpan timeout, bool abo
         /// will be offloaded to the worker thread pool so it is important to choose the value for the concurrency wisely to avoid thread pool overloading.
         /// <see cref="IAsyncBasicConsumer"/> can handle concurrency much more efficiently due to the non-blocking nature of the consumer.
         ///
-        /// Defaults to <see cref="IConnectionFactory.ConsumerDispatchConcurrency"/>.
+        /// The default value is 1.
         /// 
         /// For concurrency greater than one this removes the guarantee that consumers handle messages in the order they receive them.
         /// In addition to that consumers need to be thread/concurrency safe.
         /// </param>
         /// <param name="cancellationToken">Cancellation token</param>
-        Task<IChannel> CreateChannelAsync(ushort consumerDispatchConcurrency, CancellationToken cancellationToken = default);
+        Task<IChannel> CreateChannelAsync(ushort consumerDispatchConcurrency = Constants.DefaultConsumerDispatchConcurrency,
+            CancellationToken cancellationToken = default);
     }
 }
diff --git a/projects/RabbitMQ.Client/client/api/IConnectionExtensions.cs b/projects/RabbitMQ.Client/client/api/IConnectionExtensions.cs
@@ -7,12 +7,6 @@ namespace RabbitMQ.Client
 {
     public static class IConnectionExtensions
     {
-        /// <summary>
-        /// Asynchronously create and return a fresh channel, session, and channel.
-        /// </summary>
-        public static Task<IChannel> CreateChannelAsync(this IConnection connection, CancellationToken cancellationToken = default) =>
-            connection.CreateChannelAsync(ConnectionFactory.DefaultConsumerDispatchConcurrency, cancellationToken);
-
         /// <summary>
         /// Asynchronously close this connection and all its channels.
         /// </summary>
diff --git a/projects/RabbitMQ.Client/client/framing/Channel.cs b/projects/RabbitMQ.Client/client/framing/Channel.cs
@@ -38,7 +38,8 @@ namespace RabbitMQ.Client.Framing.Impl
 {
     internal class Channel : ChannelBase
     {
-        public Channel(ConnectionConfig config, ISession session, ushort consumerDispatchConcurrency)
+        public Channel(ConnectionConfig config, ISession session,
+            ushort consumerDispatchConcurrency = Constants.DefaultConsumerDispatchConcurrency)
             : base(config, session, consumerDispatchConcurrency)
         {
         }
diff --git a/projects/RabbitMQ.Client/client/framing/Constants.cs b/projects/RabbitMQ.Client/client/framing/Constants.cs
@@ -83,5 +83,13 @@ public static class Constants
         public const int NotImplemented = 540;
         ///<summary>(= 541)</summary>
         public const int InternalError = 541;
+
+        /// <summary>
+        /// The default consumer dispatch concurrency. See <see cref="IConnectionFactory.ConsumerDispatchConcurrency"/>
+        /// to set this value for every channel created on a connection,
+        /// and <see cref="IConnection.CreateChannelAsync(ushort, System.Threading.CancellationToken)"/>
+        /// for setting this value for a particular channel.
+        /// </summary>
+        public const ushort DefaultConsumerDispatchConcurrency = 1;
     }
 }
diff --git a/projects/RabbitMQ.Client/client/impl/AutorecoveringConnection.cs b/projects/RabbitMQ.Client/client/impl/AutorecoveringConnection.cs
@@ -240,12 +240,14 @@ await CloseInnerConnectionAsync()
             }
         }
 
-        public async Task<IChannel> CreateChannelAsync(ushort consumerDispatchConcurrency, CancellationToken cancellationToken = default)
+        public async Task<IChannel> CreateChannelAsync(ushort consumerDispatchConcurrency = Constants.DefaultConsumerDispatchConcurrency,
+            CancellationToken cancellationToken = default)
         {
             EnsureIsOpen();
-            RecoveryAwareChannel recoveryAwareChannel = await CreateNonRecoveringChannelAsync(consumerDispatchConcurrency, cancellationToken)
+            ushort cdc = DetermineConsumerDispatchConcurrency(_config, consumerDispatchConcurrency);
+            RecoveryAwareChannel recoveryAwareChannel = await CreateNonRecoveringChannelAsync(cdc, cancellationToken)
                 .ConfigureAwait(false);
-            AutorecoveringChannel channel = new AutorecoveringChannel(this, recoveryAwareChannel, consumerDispatchConcurrency);
+            AutorecoveringChannel channel = new AutorecoveringChannel(this, recoveryAwareChannel, cdc);
             await RecordChannelAsync(channel, channelsSemaphoreHeld: false, cancellationToken: cancellationToken)
                 .ConfigureAwait(false);
             return channel;
@@ -279,6 +281,16 @@ public void Dispose()
         private void EnsureIsOpen()
             => InnerConnection.EnsureIsOpen();
 
+        private static ushort DetermineConsumerDispatchConcurrency(ConnectionConfig config, ushort perChannelConsumerDispatchConcurrency)
+        {
+            ushort cdc = config.ConsumerDispatchConcurrency;
+            if (perChannelConsumerDispatchConcurrency > Constants.DefaultConsumerDispatchConcurrency)
+            {
+                cdc = perChannelConsumerDispatchConcurrency;
+            }
+            return cdc;
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void ThrowIfDisposed()
         {
diff --git a/projects/RabbitMQ.Client/client/impl/ChannelBase.cs b/projects/RabbitMQ.Client/client/impl/ChannelBase.cs
@@ -73,10 +73,12 @@ internal abstract class ChannelBase : IChannel, IRecoverable
 
         internal readonly IConsumerDispatcher ConsumerDispatcher;
 
-        protected ChannelBase(ConnectionConfig config, ISession session, ushort consumerDispatchConcurrency)
+        protected ChannelBase(ConnectionConfig config, ISession session,
+            ushort consumerDispatchConcurrency = Constants.DefaultConsumerDispatchConcurrency)
         {
             ContinuationTimeout = config.ContinuationTimeout;
-            ConsumerDispatcher = new AsyncConsumerDispatcher(this, consumerDispatchConcurrency);
+            ConsumerDispatcher = BuildConsumerDispatcher(config, consumerDispatchConcurrency);
+
             Action<Exception, string> onException = (exception, context) =>
                 OnCallbackException(CallbackExceptionEventArgs.Build(exception, context));
             _basicAcksWrapper = new EventingWrapper<BasicAckEventArgs>("OnBasicAck", onException);
@@ -92,6 +94,16 @@ protected ChannelBase(ConnectionConfig config, ISession session, ushort consumer
             Session = session;
         }
 
+        private IConsumerDispatcher BuildConsumerDispatcher(ConnectionConfig config, ushort perChannelConsumerDispatchConcurrency)
+        {
+            ushort cdc = config.ConsumerDispatchConcurrency;
+            if (perChannelConsumerDispatchConcurrency > Constants.DefaultConsumerDispatchConcurrency)
+            {
+                cdc = perChannelConsumerDispatchConcurrency;
+            }
+            return new AsyncConsumerDispatcher(this, cdc);
+        }
+
         internal TimeSpan HandshakeContinuationTimeout { get; set; } = TimeSpan.FromSeconds(10);
         public TimeSpan ContinuationTimeout { get; set; }
 
diff --git a/projects/RabbitMQ.Client/client/impl/Connection.cs b/projects/RabbitMQ.Client/client/impl/Connection.cs
@@ -72,7 +72,7 @@ internal Connection(ConnectionConfig config, IFrameHandler frameHandler)
 
             _sessionManager = new SessionManager(this, 0, config.MaxInboundMessageBodySize);
             _session0 = new MainSession(this, config.MaxInboundMessageBodySize);
-            _channel0 = new Channel(_config, _session0, ConnectionFactory.DefaultConsumerDispatchConcurrency); ;
+            _channel0 = new Channel(_config, _session0);
 
             ClientProperties = new Dictionary<string, object?>(_config.ClientProperties)
             {
@@ -253,7 +253,8 @@ await CloseAsync(ea, true,
             }
         }
 
-        public Task<IChannel> CreateChannelAsync(ushort consumerDispatchConcurrency, CancellationToken cancellationToken = default)
+        public Task<IChannel> CreateChannelAsync(ushort consumerDispatchConcurrency = Constants.DefaultConsumerDispatchConcurrency,
+            CancellationToken cancellationToken = default)
         {
             EnsureIsOpen();
             ISession session = CreateSession();
diff --git a/projects/RabbitMQ.Client/client/impl/ConsumerDispatching/ConsumerDispatcherChannelBase.cs b/projects/RabbitMQ.Client/client/impl/ConsumerDispatching/ConsumerDispatcherChannelBase.cs
@@ -16,13 +16,15 @@ internal abstract class ConsumerDispatcherChannelBase : ConsumerDispatcherBase,
         private readonly Task _worker;
         private bool _quiesce = false;
         private bool _disposed;
+        private ushort _concurrency;
 
         internal ConsumerDispatcherChannelBase(ChannelBase channel, ushort concurrency)
         {
             _channel = channel;
+            _concurrency = concurrency;
             var workChannel = Channel.CreateUnbounded<WorkStruct>(new UnboundedChannelOptions
             {
-                SingleReader = concurrency == 1,
+                SingleReader = _concurrency == 1,
                 SingleWriter = false,
                 AllowSynchronousContinuations = false
             });
@@ -36,22 +38,18 @@ internal ConsumerDispatcherChannelBase(ChannelBase channel, ushort concurrency)
             }
             else
             {
-                var tasks = new Task[concurrency];
-                for (int i = 0; i < concurrency; i++)
+                var tasks = new Task[_concurrency];
+                for (int i = 0; i < _concurrency; i++)
                 {
                     tasks[i] = Task.Run(loopStart);
                 }
                 _worker = Task.WhenAll(tasks);
             }
         }
 
-        public bool IsShutdown
-        {
-            get
-            {
-                return _quiesce;
-            }
-        }
+        public bool IsShutdown => _quiesce;
+
+        public ushort Concurrency => _concurrency;
 
         public ValueTask HandleBasicConsumeOkAsync(IAsyncBasicConsumer consumer, string consumerTag, CancellationToken cancellationToken)
         {
diff --git a/projects/RabbitMQ.Client/client/impl/ConsumerDispatching/IConsumerDispatcher.cs b/projects/RabbitMQ.Client/client/impl/ConsumerDispatching/IConsumerDispatcher.cs
@@ -41,6 +41,8 @@ internal interface IConsumerDispatcher : IDisposable
 
         bool IsShutdown { get; }
 
+        ushort Concurrency { get; }
+
         IAsyncBasicConsumer GetAndRemoveConsumer(string tag);
 
         ValueTask HandleBasicConsumeOkAsync(IAsyncBasicConsumer consumer, string consumerTag, CancellationToken cancellationToken);
diff --git a/projects/Test/Common/IntegrationFixture.cs b/projects/Test/Common/IntegrationFixture.cs
@@ -71,7 +71,7 @@ public abstract class IntegrationFixture : IAsyncLifetime
         protected readonly ITestOutputHelper _output;
         protected readonly string _testDisplayName;
 
-        protected readonly ushort _consumerDispatchConcurrency = 1;
+        protected readonly ushort _consumerDispatchConcurrency = Constants.DefaultConsumerDispatchConcurrency;
         protected readonly bool _openChannel = true;
 
         public static readonly TimeSpan ShortSpan;
@@ -109,7 +109,7 @@ static IntegrationFixture()
         }
 
         public IntegrationFixture(ITestOutputHelper output,
-            ushort consumerDispatchConcurrency = 1,
+            ushort consumerDispatchConcurrency = Constants.DefaultConsumerDispatchConcurrency,
             bool openChannel = true)
         {
             _consumerDispatchConcurrency = consumerDispatchConcurrency;
@@ -144,7 +144,6 @@ public virtual async Task InitializeAsync()
             if (_connFactory == null)
             {
                 _connFactory = CreateConnectionFactory();
-                _connFactory.ConsumerDispatchConcurrency = _consumerDispatchConcurrency;
             }
 
             if (_conn == null)
@@ -153,7 +152,8 @@ public virtual async Task InitializeAsync()
 
                 if (_openChannel)
                 {
-                    _channel = await _conn.CreateChannelAsync();
+                    _channel = await _conn.CreateChannelAsync(
+                        consumerDispatchConcurrency: _consumerDispatchConcurrency);
                 }
 
                 if (IsVerbose)
diff --git a/projects/Test/Integration/TestAsyncConsumer.cs b/projects/Test/Integration/TestAsyncConsumer.cs
diff --git a/projects/Test/Integration/TestAsyncEventingBasicConsumer.cs b/projects/Test/Integration/TestAsyncEventingBasicConsumer.cs
diff --git a/projects/Test/Integration/TestConcurrentAccessBase.cs.cs b/projects/Test/Integration/TestConcurrentAccessBase.cs.cs

Original file line number	Diff line number	Diff line change
`@@ -9,9 +9,10 @@ namespace Benchmarks.Networking`
`9`	`9`	`[MemoryDiagnoser]`
`10`	`10`	`public class Networking_BasicDeliver_Commons`
`11`	`11`	`{`
`12`		`- public static async Task Publish_Hello_World(IConnection connection, uint messageCount, byte[] body)`
	`12`	`+ public static async Task Publish_Hello_World(IConnection connection,`
	`13`	`+ uint messageCount, byte[] body, ushort consumerDispatchConcurrency = 1)`
`13`	`14`	`{`
`14`		`- using (IChannel channel = await connection.CreateChannelAsync())`
	`15`	`+ using (IChannel channel = await connection.CreateChannelAsync(consumerDispatchConcurrency))`
`15`	`16`	`{`
`16`	`17`	`QueueDeclareOk queue = await channel.QueueDeclareAsync();`
`17`	`18`	`var consumer = new CountingConsumer(channel, messageCount);`
Original file line number	Diff line number	Diff line change
`@@ -29,16 +29,17 @@ public void GlobalCleanup()`
`29`	`29`	`[Benchmark(Baseline = true)]`
`30`	`30`	`public async Task Publish_Hello_World()`
`31`	`31`	`{`
`32`		`- var cf = new ConnectionFactory { ConsumerDispatchConcurrency = 2 };`
	`32`	`+ var cf = new ConnectionFactory();`
`33`	`33`	`using (IConnection connection = await cf.CreateConnectionAsync())`
`34`	`34`	`{`
`35`		`- await Publish_Hello_World(connection);`
	`35`	`+ await Publish_Hello_World(connection, 2);`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`
`39`		`- public static async Task Publish_Hello_World(IConnection connection)`
	`39`	`+ public static async Task Publish_Hello_World(IConnection connection, ushort consumerDispatchConcurrency)`
`40`	`40`	`{`
`41`		`- await Networking_BasicDeliver_Commons.Publish_Hello_World(connection, messageCount, _body);`
	`41`	`+ await Networking_BasicDeliver_Commons.Publish_Hello_World(connection, messageCount, _body,`
	`42`	`+ consumerDispatchConcurrency);`
`42`	`43`	`}`
`43`	`44`	`}`
`44`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,7 @@ public class Networking_BasicDeliver_LongLivedConnection`
`19`	`19`	`public void GlobalSetup()`
`20`	`20`	`{`
`21`	`21`	`_container = RabbitMQBroker.Start();`
`22`		`-`
`23`		`- var cf = new ConnectionFactory { ConsumerDispatchConcurrency = 2 };`
	`22`	`+ var cf = new ConnectionFactory();`
`24`	`23`	`// NOTE: https://github.com/dotnet/BenchmarkDotNet/issues/1738`
`25`	`24`	`_connection = EnsureCompleted(cf.CreateConnectionAsync());`
`26`	`25`	`}`
`@@ -35,7 +34,8 @@ public void GlobalCleanup()`
`35`	`34`	`[Benchmark(Baseline = true)]`
`36`	`35`	`public Task Publish_Hello_World()`
`37`	`36`	`{`
`38`		`- return Networking_BasicDeliver_Commons.Publish_Hello_World(_connection, messageCount, _body);`
	`37`	`+ return Networking_BasicDeliver_Commons.Publish_Hello_World(_connection, messageCount, _body,`
	`38`	`+ consumerDispatchConcurrency: 2);`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`private static T EnsureCompleted<T>(Task<T> task) => task.GetAwaiter().GetResult();`
Original file line number	Diff line number	Diff line change
`@@ -7,12 +7,6 @@ namespace RabbitMQ.Client`
`7`	`7`	`{`
`8`	`8`	`public static class IConnectionExtensions`
`9`	`9`	`{`
`10`		`- /// <summary>`
`11`		`- /// Asynchronously create and return a fresh channel, session, and channel.`
`12`		`- /// </summary>`
`13`		`- public static Task<IChannel> CreateChannelAsync(this IConnection connection, CancellationToken cancellationToken = default) =>`
`14`		`- connection.CreateChannelAsync(ConnectionFactory.DefaultConsumerDispatchConcurrency, cancellationToken);`
`15`		`-`
`16`	`10`	`/// <summary>`
`17`	`11`	`/// Asynchronously close this connection and all its channels.`
`18`	`12`	`/// </summary>`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,8 @@ namespace RabbitMQ.Client.Framing.Impl`
`38`	`38`	`{`
`39`	`39`	`internal class Channel : ChannelBase`
`40`	`40`	`{`
`41`		`- public Channel(ConnectionConfig config, ISession session, ushort consumerDispatchConcurrency)`
	`41`	`+ public Channel(ConnectionConfig config, ISession session,`
	`42`	`+ ushort consumerDispatchConcurrency = Constants.DefaultConsumerDispatchConcurrency)`
`42`	`43`	`: base(config, session, consumerDispatchConcurrency)`
`43`	`44`	`{`
`44`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -83,5 +83,13 @@ public static class Constants`
`83`	`83`	`public const int NotImplemented = 540;`
`84`	`84`	`///<summary>(= 541)</summary>`
`85`	`85`	`public const int InternalError = 541;`
	`86`	`+`
	`87`	`+ /// <summary>`
	`88`	`+ /// The default consumer dispatch concurrency. See <see cref="IConnectionFactory.ConsumerDispatchConcurrency"/>`
	`89`	`+ /// to set this value for every channel created on a connection,`
	`90`	`+ /// and <see cref="IConnection.CreateChannelAsync(ushort, System.Threading.CancellationToken)"/>`
	`91`	`+ /// for setting this value for a particular channel.`
	`92`	`+ /// </summary>`
	`93`	`+ public const ushort DefaultConsumerDispatchConcurrency = 1;`
`86`	`94`	`}`
`87`	`95`	`}`