Replace Where+FirstOrDefault call with FirstOrDefault. Also few cleanups (typos, removed unused usings, changing some methods to private) (#9096)

kshyju · web-flow · commit 9b329463e6b0 · 2023-02-15T15:43:18.000-08:00
diff --git a/src/WebJobs.Script.Grpc/Channel/GrpcWorkerChannelFactory.cs b/src/WebJobs.Script.Grpc/Channel/GrpcWorkerChannelFactory.cs
@@ -4,7 +4,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Reactive.Linq;
 using Microsoft.Azure.WebJobs.Script.Config;
 using Microsoft.Azure.WebJobs.Script.Diagnostics;
 using Microsoft.Azure.WebJobs.Script.Eventing;
@@ -44,10 +43,10 @@ public GrpcWorkerChannelFactory(IScriptEventManager eventManager, IEnvironment e
 
         public IRpcWorkerChannel Create(string scriptRootPath, string runtime, IMetricsLogger metricsLogger, int attemptCount, IEnumerable<RpcWorkerConfig> workerConfigs)
         {
-            var languageWorkerConfig = workerConfigs.Where(c => c.Description.Language.Equals(runtime, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
+            var languageWorkerConfig = workerConfigs.FirstOrDefault(c => c.Description.Language.Equals(runtime, StringComparison.OrdinalIgnoreCase));
             if (languageWorkerConfig == null)
             {
-                throw new InvalidOperationException($"WorkerCofig for runtime: {runtime} not found");
+                throw new InvalidOperationException($"WorkerConfig for runtime: {runtime} not found");
             }
             string workerId = Guid.NewGuid().ToString();
             _eventManager.AddGrpcChannels(workerId); // prepare the inbound/outbound dedicated channels
diff --git a/src/WebJobs.Script/Description/FunctionGenerator.cs b/src/WebJobs.Script/Description/FunctionGenerator.cs
@@ -53,7 +53,7 @@ public static Type Generate(string functionAssemblyName, string typeName, Collec
                     continue;
                 }
 
-                var retValue = function.Parameters.Where(x => x.Name == ScriptConstants.SystemReturnParameterName).FirstOrDefault();
+                var retValue = function.Parameters.FirstOrDefault(x => x.Name == ScriptConstants.SystemReturnParameterName);
                 var parameters = function.Parameters.Where(x => x != retValue).ToArray();
 
                 MethodBuilder methodBuilder = tb.DefineMethod(function.Name, MethodAttributes.Public | MethodAttributes.Static);
diff --git a/src/WebJobs.Script/Utility.cs b/src/WebJobs.Script/Utility.cs
@@ -37,8 +37,8 @@ public static class Utility
     {
         // Prefix that uniquely identifies our assemblies
         // i.e.: "f-<functionname>"
-        public const string AssemblyPrefix = "f-";
-        public const string AssemblySeparator = "__";
+        private const string AssemblyPrefix = "f-";
+        private const string AssemblySeparator = "__";
         private const string BlobServiceDomain = "blob";
         private const string SasVersionQueryParam = "sv";
 
@@ -153,7 +153,7 @@ internal static async Task InvokeWithRetriesAsync(Func<Task> action, int maxRetr
         /// </summary>
         /// <param name="timeoutSeconds">The maximum number of seconds to delay.</param>
         /// <param name="pollingIntervalMilliseconds">The polling interval.</param>
-        /// <param name="condition">The condition to check</param>
+        /// <param name="condition">The condition to check.</param>
         /// <returns>A Task representing the delay.</returns>
         internal static Task<bool> DelayAsync(int timeoutSeconds, int pollingIntervalMilliseconds, Func<bool> condition)
         {
@@ -166,7 +166,7 @@ internal static Task<bool> DelayAsync(int timeoutSeconds, int pollingIntervalMil
         /// </summary>
         /// <param name="timeoutSeconds">The maximum number of seconds to delay.</param>
         /// <param name="pollingIntervalMilliseconds">The polling interval.</param>
-        /// <param name="condition">The async condition to check</param>
+        /// <param name="condition">The async condition to check.</param>
         /// <returns>A Task representing the delay.</returns>
         internal static Task<bool> DelayAsync(int timeoutSeconds, int pollingIntervalMilliseconds, Func<Task<bool>> condition, CancellationToken cancellationToken)
         {
@@ -279,7 +279,7 @@ public static bool IsValidUserType(Type type)
 
         public static IReadOnlyDictionary<string, string> ToStringValues(this IReadOnlyDictionary<string, object> data)
         {
-            return data.ToDictionary(p => p.Key, p => p.Value != null ? p.Value.ToString() : null, StringComparer.OrdinalIgnoreCase);
+            return data.ToDictionary(p => p.Key, p => p.Value?.ToString(), StringComparer.OrdinalIgnoreCase);
         }
 
         public static string GetValueOrNull(this StringDictionary dictionary, string key)
@@ -365,7 +365,7 @@ public static string FlattenException(Exception ex, Func<string, string> sourceF
 
         /// <summary>
         /// Applies any additional binding data from the input value to the specified binding data.
-        /// This binding data then becomes available to the binding process (in the case of late bound bindings)
+        /// This binding data then becomes available to the binding process (in the case of late bound bindings).
         /// </summary>
         internal static void ApplyBindingData(object value, Dictionary<string, object> bindingData)
         {
@@ -441,9 +441,9 @@ public static string ToLowerFirstCharacter(string input)
         }
 
         /// <summary>
-        /// Checks if a given string has a UTF8 BOM
+        /// Checks if a given string has a UTF8 BOM.
         /// </summary>
-        /// <param name="input">The string to be evalutated</param>
+        /// <param name="input">The string to be evaluated.</param>
         /// <returns>True if the string begins with a UTF8 BOM; Otherwise, false.</returns>
         public static bool HasUtf8ByteOrderMark(string input)
             => input != null && CultureInfo.InvariantCulture.CompareInfo.IsPrefix(input, UTF8ByteOrderMark, CompareOptions.Ordinal);
@@ -649,11 +649,9 @@ internal static bool IsSingleLanguage(IEnumerable<FunctionMetadata> functions, s
 
         internal static string GetWorkerRuntime(IEnumerable<FunctionMetadata> functions, IEnvironment environment = null)
         {
-            string workerRuntime = null;
-
             if (environment != null)
             {
-                workerRuntime = environment.GetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime);
+                var workerRuntime = environment.GetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime);
 
                 if (!string.IsNullOrEmpty(workerRuntime))
                 {
@@ -746,7 +744,7 @@ internal static IEnumerable<FunctionMetadata> GetValidFunctions(IEnumerable<Func
                 // No valid functions
                 return null;
             }
-            return indexedFunctions.Where(m => functionDescriptors.Select(fd => fd.Metadata.Name).Contains(m.Name) == true);
+            return indexedFunctions.Where(m => functionDescriptors.Select(fd => fd.Metadata.Name).Contains(m.Name));
         }
 
         public static bool CheckAppOffline(string scriptPath)
@@ -857,10 +855,10 @@ public static bool IsHttporManualTrigger(string triggerType)
         }
 
         /// <summary>
-        /// Computes a stable non-cryptographic hash
+        /// Computes a stable non-cryptographic hash.
         /// </summary>
-        /// <param name="value">The string to use for computation</param>
-        /// <returns>A stable, non-cryptographic, hash</returns>
+        /// <param name="value">The string to use for computation.</param>
+        /// <returns>A stable, non-cryptographic, hash.</returns>
         internal static int GetStableHash(string value)
         {
             if (value == null)
@@ -933,7 +931,7 @@ public static bool CanWorkerIndex(IEnumerable<RpcWorkerConfig> workerConfigs, IE
                 && !environment.IsMultiLanguageRuntimeEnvironment())
             {
                 var workerRuntime = environment.GetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime);
-                var workerConfig = workerConfigs.Where(c => c.Description != null && c.Description.Language != null && c.Description.Language.Equals(workerRuntime, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
+                var workerConfig = workerConfigs.FirstOrDefault(c => c.Description?.Language != null && c.Description.Language.Equals(workerRuntime, StringComparison.InvariantCultureIgnoreCase));
 
                 // if feature flag is enabled and workerConfig.WorkerIndexing == true, then return true
                 if (workerConfig != null
diff --git a/src/WebJobs.Script/Workers/Rpc/FunctionRegistration/RpcFunctionInvocationDispatcher.cs b/src/WebJobs.Script/Workers/Rpc/FunctionRegistration/RpcFunctionInvocationDispatcher.cs
@@ -117,8 +117,8 @@ private async Task<int> GetMaxProcessCount()
 
             if (!string.IsNullOrEmpty(_workerRuntime))
             {
-                var workerConfig = _workerConfigs.Where(c => c.Description.Language.Equals(_workerRuntime, StringComparison.InvariantCultureIgnoreCase))
-                                                .FirstOrDefault();
+                var workerConfig = _workerConfigs
+                    .FirstOrDefault(c => c.Description.Language.Equals(_workerRuntime, StringComparison.InvariantCultureIgnoreCase));
                 if (workerConfig != null)
                 {
                     return workerConfig.CountOptions.ProcessCount;
@@ -261,7 +261,7 @@ public async Task InitializeAsync(IEnumerable<FunctionMetadata> functions, Cance
                 return;
             }
 
-            var workerConfig = _workerConfigs.Where(c => c.Description.Language.Equals(_workerRuntime, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
+            var workerConfig = _workerConfigs.FirstOrDefault(c => c.Description.Language.Equals(_workerRuntime, StringComparison.InvariantCultureIgnoreCase));
 
             // For other OOP workers, workerconfigs are present inside "workers" folder of host bin directory and is used to populate "_workerConfigs".
             // For dotnet-isolated _workerConfigs is populated by reading workerconfig.json from the deployed payload(customer function app code).
@@ -271,7 +271,7 @@ public async Task InitializeAsync(IEnumerable<FunctionMetadata> functions, Cance
 
             // We are skipping this check for multi-language environments because they use multiple workers and thus doesn't honor 'FUNCTIONS_WORKER_RUNTIME'
             // Also, skip if dotnet-isolated app without payload as it is a valid case to exist.
-            if ((workerConfig == null && (functions == null || functions.Count() == 0))
+            if (workerConfig == null && (functions == null || !functions.Any())
                 && !_environment.IsMultiLanguageRuntimeEnvironment()
                 && !isDotNetIsolatedAppWithoutPayload)
             {
@@ -283,7 +283,7 @@ public async Task InitializeAsync(IEnumerable<FunctionMetadata> functions, Cance
                 throw new InvalidOperationException($"WorkerConfig for runtime: {_workerRuntime} not found");
             }
 
-            if (functions == null || functions.Count() == 0)
+            if (functions == null || !functions.Any())
             {
                 // do not initialize function dispatcher if there are no functions, unless the worker is indexing
                 _logger.LogDebug($"{nameof(RpcFunctionInvocationDispatcher)} received no functions");
@@ -443,7 +443,7 @@ internal async Task<IEnumerable<IRpcWorkerChannel>> GetInitializedWorkerChannels
             return initializedWorkers;
         }
 
-        public async void WorkerError(WorkerErrorEvent workerError)
+        private async void WorkerError(WorkerErrorEvent workerError)
         {
             if (_disposing || _disposed)
             {
@@ -473,7 +473,7 @@ public async void WorkerError(WorkerErrorEvent workerError)
             }
         }
 
-        public async void WorkerRestart(WorkerRestartEvent workerRestart)
+        private async void WorkerRestart(WorkerRestartEvent workerRestart)
         {
             if (_disposing || _disposed)
             {
@@ -582,7 +582,7 @@ private async Task StartWorkerChannel(string runtime)
                     }
                 }
             }
-            else if (_jobHostLanguageWorkerChannelManager.GetChannels().Count() == 0)
+            else if (!_jobHostLanguageWorkerChannelManager.GetChannels().Any())
             {
                 _logger.LogError("Exceeded language worker restart retry count for runtime:{runtime}. Shutting down and proactively recycling the Functions Host to recover", runtime);
                 _applicationLifetime.StopApplication();
diff --git a/test/WebJobs.Script.Tests/UtilityTests.cs b/test/WebJobs.Script.Tests/UtilityTests.cs
@@ -3,23 +3,18 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Dynamic;
 using System.Globalization;
 using System.IO;
 using System.Linq;
-using System.Reflection;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Azure.WebJobs.Host.Scale;
 using Microsoft.Azure.WebJobs.Logging;
-using Microsoft.Azure.WebJobs.Script.Config;
 using Microsoft.Azure.WebJobs.Script.Description;
 using Microsoft.Azure.WebJobs.Script.Diagnostics;
 using Microsoft.Azure.WebJobs.Script.Models;
 using Microsoft.Azure.WebJobs.Script.Workers.Rpc;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Microsoft.WebJobs.Script.Tests;
@@ -950,7 +945,7 @@ public void TryReadAsBool_ReturnsExpectedBoolValue(object value, bool expectedVa
 
         private static void VerifyLogLevel(IList<LogMessage> allLogs, string msg, LogLevel expectedLevel)
         {
-            var message = allLogs.Where(l => l.FormattedMessage.Contains(msg)).FirstOrDefault();
+            var message = allLogs.FirstOrDefault(l => l.FormattedMessage.Contains(msg));
             Assert.NotNull(message);
             Assert.Equal(expectedLevel, message.Level);
         }
diff --git a/test/WebJobs.Script.Tests/Workers/Rpc/RpcWorkerConfigFactoryTests.cs b/test/WebJobs.Script.Tests/Workers/Rpc/RpcWorkerConfigFactoryTests.cs
@@ -107,7 +107,7 @@ public void JavaPath_FromEnvVars()
             var testLogger = new TestLogger("test");
             var configFactory = new RpcWorkerConfigFactory(config, testLogger, _testSysRuntimeInfo, _testEnvironment, new TestMetricsLogger(), _testWorkerProfileManager);
             var workerConfigs = configFactory.GetConfigs();
-            var javaPath = workerConfigs.Where(c => c.Description.Language.Equals("java", StringComparison.OrdinalIgnoreCase)).FirstOrDefault().Description.DefaultExecutablePath;
+            var javaPath = workerConfigs.FirstOrDefault(c => c.Description.Language.Equals("java", StringComparison.OrdinalIgnoreCase)).Description.DefaultExecutablePath;
             Assert.DoesNotContain(@"%JAVA_HOME%", javaPath);
             Assert.Contains(@"/bin/java", javaPath);
         }
@@ -128,8 +128,8 @@ public void DefaultWorkerConfigs_Overrides_DefaultWorkerRuntimeVersion_AppSettin
             {
                 var configFactory = new RpcWorkerConfigFactory(config, testLogger, _testSysRuntimeInfo, _testEnvironment, new TestMetricsLogger(), _testWorkerProfileManager);
                 var workerConfigs = configFactory.GetConfigs();
-                var pythonWorkerConfig = workerConfigs.Where(w => w.Description.Language.Equals("python", StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
-                var powershellWorkerConfig = workerConfigs.Where(w => w.Description.Language.Equals("powershell", StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
+                var pythonWorkerConfig = workerConfigs.FirstOrDefault(w => w.Description.Language.Equals("python", StringComparison.OrdinalIgnoreCase));
+                var powershellWorkerConfig = workerConfigs.FirstOrDefault(w => w.Description.Language.Equals("powershell", StringComparison.OrdinalIgnoreCase));
                 Assert.Equal(4, workerConfigs.Count);
                 Assert.NotNull(pythonWorkerConfig);
                 Assert.NotNull(powershellWorkerConfig);
@@ -150,7 +150,7 @@ public void DefaultWorkerConfigs_Overrides_VersionAppSetting()
             var testLogger = new TestLogger("test");
             var configFactory = new RpcWorkerConfigFactory(config, testLogger, _testSysRuntimeInfo, testEnvironment, new TestMetricsLogger(), _testWorkerProfileManager);
             var workerConfigs = configFactory.GetConfigs();
-            var powershellWorkerConfig = workerConfigs.Where(w => w.Description.Language.Equals("powershell", StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
+            var powershellWorkerConfig = workerConfigs.FirstOrDefault(w => w.Description.Language.Equals("powershell", StringComparison.OrdinalIgnoreCase));
             Assert.Equal(1, workerConfigs.Count);
             Assert.NotNull(powershellWorkerConfig);
             Assert.Equal("7.2", powershellWorkerConfig.Description.DefaultRuntimeVersion);
diff --git a/test/WebJobs.Script.Tests/Workers/Rpc/RpcWorkerConfigTests.cs b/test/WebJobs.Script.Tests/Workers/Rpc/RpcWorkerConfigTests.cs
@@ -153,7 +153,7 @@ public void ReadWorkerProviderFromConfig_InvalidConfigFile()
             var workerConfigs = TestReadWorkerProviderFromConfig(configs, testLogger, testMetricsLogger);
             AreRequiredMetricsEmitted(testMetricsLogger);
             var logs = testLogger.GetLogMessages();
-            var errorLog = logs.Where(log => log.Level == LogLevel.Error).FirstOrDefault();
+            var errorLog = logs.FirstOrDefault(log => log.Level == LogLevel.Error);
             Assert.NotNull(errorLog);
             Assert.NotNull(errorLog.Exception);
             Assert.True(errorLog.FormattedMessage.Contains("Failed to initialize"));

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,6 @@`
`4`	`4`	`using System;`
`5`	`5`	`using System.Collections.Generic;`
`6`	`6`	`using System.Linq;`
`7`		`-using System.Reactive.Linq;`
`8`	`7`	`using Microsoft.Azure.WebJobs.Script.Config;`
`9`	`8`	`using Microsoft.Azure.WebJobs.Script.Diagnostics;`
`10`	`9`	`using Microsoft.Azure.WebJobs.Script.Eventing;`
`@@ -44,10 +43,10 @@ public GrpcWorkerChannelFactory(IScriptEventManager eventManager, IEnvironment e`
`44`	`43`
`45`	`44`	`public IRpcWorkerChannel Create(string scriptRootPath, string runtime, IMetricsLogger metricsLogger, int attemptCount, IEnumerable<RpcWorkerConfig> workerConfigs)`
`46`	`45`	`{`
`47`		`- var languageWorkerConfig = workerConfigs.Where(c => c.Description.Language.Equals(runtime, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();`
	`46`	`+ var languageWorkerConfig = workerConfigs.FirstOrDefault(c => c.Description.Language.Equals(runtime, StringComparison.OrdinalIgnoreCase));`
`48`	`47`	`if (languageWorkerConfig == null)`
`49`	`48`	`{`
`50`		`- throw new InvalidOperationException($"WorkerCofig for runtime: {runtime} not found");`
	`49`	`+ throw new InvalidOperationException($"WorkerConfig for runtime: {runtime} not found");`
`51`	`50`	`}`
`52`	`51`	`string workerId = Guid.NewGuid().ToString();`
`53`	`52`	`_eventManager.AddGrpcChannels(workerId); // prepare the inbound/outbound dedicated channels`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ public static Type Generate(string functionAssemblyName, string typeName, Collec`
`53`	`53`	`continue;`
`54`	`54`	`}`
`55`	`55`
`56`		`- var retValue = function.Parameters.Where(x => x.Name == ScriptConstants.SystemReturnParameterName).FirstOrDefault();`
	`56`	`+ var retValue = function.Parameters.FirstOrDefault(x => x.Name == ScriptConstants.SystemReturnParameterName);`
`57`	`57`	`var parameters = function.Parameters.Where(x => x != retValue).ToArray();`
`58`	`58`
`59`	`59`	`MethodBuilder methodBuilder = tb.DefineMethod(function.Name, MethodAttributes.Public \| MethodAttributes.Static);`
Original file line number	Diff line number	Diff line change
`@@ -117,8 +117,8 @@ private async Task<int> GetMaxProcessCount()`
`117`	`117`
`118`	`118`	`if (!string.IsNullOrEmpty(_workerRuntime))`
`119`	`119`	`{`
`120`		`- var workerConfig = _workerConfigs.Where(c => c.Description.Language.Equals(_workerRuntime, StringComparison.InvariantCultureIgnoreCase))`
`121`		`- .FirstOrDefault();`
	`120`	`+ var workerConfig = _workerConfigs`
	`121`	`+ .FirstOrDefault(c => c.Description.Language.Equals(_workerRuntime, StringComparison.InvariantCultureIgnoreCase));`
`122`	`122`	`if (workerConfig != null)`
`123`	`123`	`{`
`124`	`124`	`return workerConfig.CountOptions.ProcessCount;`
`@@ -261,7 +261,7 @@ public async Task InitializeAsync(IEnumerable<FunctionMetadata> functions, Cance`
`261`	`261`	`return;`
`262`	`262`	`}`
`263`	`263`
`264`		`- var workerConfig = _workerConfigs.Where(c => c.Description.Language.Equals(_workerRuntime, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();`
	`264`	`+ var workerConfig = _workerConfigs.FirstOrDefault(c => c.Description.Language.Equals(_workerRuntime, StringComparison.InvariantCultureIgnoreCase));`
`265`	`265`
`266`	`266`	`// For other OOP workers, workerconfigs are present inside "workers" folder of host bin directory and is used to populate "_workerConfigs".`
`267`	`267`	`// For dotnet-isolated _workerConfigs is populated by reading workerconfig.json from the deployed payload(customer function app code).`
`@@ -271,7 +271,7 @@ public async Task InitializeAsync(IEnumerable<FunctionMetadata> functions, Cance`
`271`	`271`
`272`	`272`	`// We are skipping this check for multi-language environments because they use multiple workers and thus doesn't honor 'FUNCTIONS_WORKER_RUNTIME'`
`273`	`273`	`// Also, skip if dotnet-isolated app without payload as it is a valid case to exist.`
`274`		`- if ((workerConfig == null && (functions == null \|\| functions.Count() == 0))`
	`274`	`+ if (workerConfig == null && (functions == null \|\| !functions.Any())`
`275`	`275`	`&& !_environment.IsMultiLanguageRuntimeEnvironment()`
`276`	`276`	`&& !isDotNetIsolatedAppWithoutPayload)`
`277`	`277`	`{`
`@@ -283,7 +283,7 @@ public async Task InitializeAsync(IEnumerable<FunctionMetadata> functions, Cance`
`283`	`283`	`throw new InvalidOperationException($"WorkerConfig for runtime: {_workerRuntime} not found");`
`284`	`284`	`}`
`285`	`285`
`286`		`- if (functions == null \|\| functions.Count() == 0)`
	`286`	`+ if (functions == null \|\| !functions.Any())`
`287`	`287`	`{`
`288`	`288`	`// do not initialize function dispatcher if there are no functions, unless the worker is indexing`
`289`	`289`	`_logger.LogDebug($"{nameof(RpcFunctionInvocationDispatcher)} received no functions");`
`@@ -443,7 +443,7 @@ internal async Task<IEnumerable<IRpcWorkerChannel>> GetInitializedWorkerChannels`
`443`	`443`	`return initializedWorkers;`
`444`	`444`	`}`
`445`	`445`
`446`		`- public async void WorkerError(WorkerErrorEvent workerError)`
	`446`	`+ private async void WorkerError(WorkerErrorEvent workerError)`
`447`	`447`	`{`
`448`	`448`	`if (_disposing \|\| _disposed)`
`449`	`449`	`{`
`@@ -473,7 +473,7 @@ public async void WorkerError(WorkerErrorEvent workerError)`
`473`	`473`	`}`
`474`	`474`	`}`
`475`	`475`
`476`		`- public async void WorkerRestart(WorkerRestartEvent workerRestart)`
	`476`	`+ private async void WorkerRestart(WorkerRestartEvent workerRestart)`
`477`	`477`	`{`
`478`	`478`	`if (_disposing \|\| _disposed)`
`479`	`479`	`{`
`@@ -582,7 +582,7 @@ private async Task StartWorkerChannel(string runtime)`
`582`	`582`	`}`
`583`	`583`	`}`
`584`	`584`	`}`
`585`		`- else if (_jobHostLanguageWorkerChannelManager.GetChannels().Count() == 0)`
	`585`	`+ else if (!_jobHostLanguageWorkerChannelManager.GetChannels().Any())`
`586`	`586`	`{`
`587`	`587`	`_logger.LogError("Exceeded language worker restart retry count for runtime:{runtime}. Shutting down and proactively recycling the Functions Host to recover", runtime);`
`588`	`588`	`_applicationLifetime.StopApplication();`