Add Newtonsoft CamelCase config support

Allow to use "Azure:SignalR:HubProtocol:Newtonsoft:CamelCase=true" to enable camelcase.

src/SignalRServiceExtension/Config/DependencyInjectionExtensions.cs

@@ -2,31 +2,43 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
-using Microsoft.AspNetCore.SignalR.Protocol;
+using Microsoft.Azure.SignalR.Management;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.DependencyInjection.Extensions;
+using Newtonsoft.Json;
 
 namespace Microsoft.Azure.WebJobs.Extensions.SignalRService
 {
     internal static class DependencyInjectionExtensions
     {
-        private const string HubProtocolError = "It's invalid to configure hub protocol on Azure Functions runtime V2. Newtonsoft.Json protocol will be used.";
+        private const string HubProtocolError = "It's invalid to set hub protocol to System.Text.Json on Azure Functions runtime V2.";
 
         public static IServiceCollection SetHubProtocol(this IServiceCollection services, IConfiguration configuration)
         {
-            if (Environment.Version.Major == 4 && configuration[Constants.AzureSignalRHubProtocol] != null)
+            var hubProtocolConfig = configuration[Constants.AzureSignalRHubProtocol];
+            if (hubProtocolConfig != null)
             {
-                // Actually is .Net Core 2.x
-                throw new InvalidOperationException(HubProtocolError);
+                var hubProtocol = Enum.Parse<HubProtocol>(hubProtocolConfig);
+                if (Environment.Version.Major == 4 && hubProtocol == HubProtocol.SystemTextJson)
+                {
+                    // .Net Core 2.x is always Newtonsoft.Json.
+                    throw new InvalidOperationException(HubProtocolError);
+                }
+                //If hubProtocolConfig is SystemTextJson for .Net Core 3.1, do nothing, as transient mode doesn't accept it and persisent mode is already System.Text.Json by default.
+                if (!DotnetRuntime(configuration) || hubProtocol == HubProtocol.NewtonsoftJson)
+                {
+                    if (configuration.GetValue(Constants.AzureSignalRNewtonsoftCamelCase, false))
+                    {
+                        // The default options is camelCase.
+                        services.AddNewtonsoftHubProtocol(o => { });
+                    }
+                    else
+                    {
+                        // Reset the options to keep backward compatibility.
+                        services.AddNewtonsoftHubProtocol(o => o.PayloadSerializerSettings = new JsonSerializerSettings());
+                    }
+                }
             }
-#if NETCOREAPP3_1 || NETCOREAPP3_0 || NETSTANDARD2_0 
-            else if (!DotnetRuntime(configuration) || UserSpecifyNewtonsoft(configuration))
-            {
-                // .Net Core 3.1, overwrite the System.Text.Json Protocol.
-                services.TryAddEnumerable(ServiceDescriptor.Singleton<IHubProtocol, NewtonsoftJsonHubProtocol>());
-            }
-#endif
             return services;
         }
 
@@ -36,10 +48,5 @@ private static bool DotnetRuntime(IConfiguration configuration)
             //unit test environment
             return workerRuntime == null || workerRuntime == Constants.DotnetWorker;
         }
-
-        private static bool UserSpecifyNewtonsoft(IConfiguration configuration)
-        {
-            return configuration.GetValue(Constants.AzureSignalRHubProtocol, HubProtocol.SystemTextJson) == HubProtocol.NewtonsoftJson;
-        }
     }
 }

src/SignalRServiceExtension/Constants.cs

@@ -8,6 +8,7 @@ internal static class Constants
         public const string AzureSignalRConnectionStringName = "AzureSignalRConnectionString";
         public const string AzureSignalREndpoints = "Azure:SignalR:Endpoints";
         public const string AzureSignalRHubProtocol = "Azure:SignalR:HubProtocol";
+        public const string AzureSignalRNewtonsoftCamelCase = "Azure:SignalR:HubProtocol:Newtonsoft:CamelCase";
         public const string ServiceTransportTypeName = "AzureSignalRServiceTransportType";
         public const string AsrsHeaderPrefix = "X-ASRS-";
         public const string AsrsConnectionIdHeader = AsrsHeaderPrefix + "Connection-Id";

test/SignalRServiceExtension.Tests/Config/DependencyInjectionExtensionFacts.cs

@@ -3,10 +3,17 @@
 
 using System;
 using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.SignalR;
 using Microsoft.AspNetCore.SignalR.Protocol;
+using Microsoft.Azure.SignalR.Management;
+using Microsoft.Azure.SignalR.Tests.Common;
 using Microsoft.Azure.WebJobs.Extensions.SignalRService;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
+using Newtonsoft.Json.Serialization;
 using Xunit;
 
 namespace SignalRServiceExtension.Tests
@@ -22,6 +29,18 @@ public void EmptyHubProtocolSetting_DoNothing()
             Assert.Empty(services);
         }
 
+        [Fact]
+        public async Task SetNewtonsoftCamelCaseInTransientModeAsync()
+        {
+            var serviceManagerStore = CreateServiceManagerStore(out var configuration);
+            var hubContext = await serviceManagerStore.GetOrAddByConnectionStringKey(Constants.AzureSignalRConnectionStringName).GetAsync("hub") as ServiceHubContextImpl;
+
+            var restHubProtocol = hubContext.ServiceProvider.GetRequiredService<IRestHubProtocol>();
+            Assert.IsType<NewtonsoftRestHubProtocol>(restHubProtocol);
+            var newtonsoftOptions = hubContext.ServiceProvider.GetRequiredService<IOptions<NewtonsoftServiceHubProtocolOptions>>();
+            Assert.IsType<CamelCasePropertyNamesContractResolver>(newtonsoftOptions.Value.PayloadSerializerSettings.ContractResolver);
+        }
+
 #if NETCOREAPP2_1
 
         [Fact]
@@ -33,6 +52,19 @@ public void SetHubProtocol_Throw()
             Assert.Throws<InvalidOperationException>(() => services.SetHubProtocol(configuration));
         }
 
+        [Fact]
+        public async Task SetNewtonsoftCamelCaseInPersistentModeAsync()
+        {
+            var serviceManagerStore = CreateServiceManagerStore(out var configuration);
+            configuration[Constants.ServiceTransportTypeName] = "Persistent";
+            var hubContext = await serviceManagerStore.GetOrAddByConnectionStringKey(Constants.AzureSignalRConnectionStringName).GetAsync("hub") as ServiceHubContextImpl;
+            var hubProtocol = hubContext.ServiceProvider.GetRequiredService<IHubProtocol>();
+            // on .Net Core 2.1, JsonHubProtocol stands for Newtonsoft.Json protocol
+            Assert.IsType<JsonHubProtocol>(hubProtocol);
+            var newtonsoftOptions = hubContext.ServiceProvider.GetRequiredService<IOptions<JsonHubProtocolOptions>>();
+            Assert.IsType<CamelCasePropertyNamesContractResolver>(newtonsoftOptions.Value.PayloadSerializerSettings.ContractResolver);
+        }
+
 #endif
 
 #if NETCOREAPP3_1
@@ -57,6 +89,28 @@ public void SetNewtonsoft()
             var hubProtocolImpl = services.Single().ImplementationType;
             Assert.Equal(typeof(NewtonsoftJsonHubProtocol), hubProtocolImpl);
         }
+
+        [Fact]
+        public async Task SetNewtonsoftPersistent()
+        {
+            var serviceManagerStore = CreateServiceManagerStore(out var configuration);
+            configuration[Constants.ServiceTransportTypeName] = "Persistent";
+            var hubContext = await serviceManagerStore.GetOrAddByConnectionStringKey(Constants.AzureSignalRConnectionStringName).GetAsync("hub") as ServiceHubContextImpl;
+            var hubProtocol = hubContext.ServiceProvider.GetRequiredService<IHubProtocol>();
+            Assert.IsType<NewtonsoftJsonHubProtocol>(hubProtocol);
+            var newtonsoftOptions = hubContext.ServiceProvider.GetRequiredService<IOptions<NewtonsoftJsonHubProtocolOptions>>();
+            Assert.IsType<CamelCasePropertyNamesContractResolver>(newtonsoftOptions.Value.PayloadSerializerSettings.ContractResolver);
+        }
 #endif
+
+        private ServiceManagerStore CreateServiceManagerStore(out IConfiguration configuration)
+        {
+            configuration = new ConfigurationBuilder().AddInMemoryCollection().Build();
+            configuration[Constants.AzureSignalRHubProtocol] = HubProtocol.NewtonsoftJson.ToString();
+            configuration[Constants.AzureSignalRNewtonsoftCamelCase] = "true";
+            configuration[Constants.AzureSignalRConnectionStringName] = FakeEndpointUtils.GetFakeConnectionString(1).Single();
+
+            return new ServiceManagerStore(configuration, NullLoggerFactory.Instance, null);
+        }
     }
 }