Fix all IDE0039 warnings, prefer local functions

src/Azure/Shared/Storage/AzureTableDataManager.cs

@@ -510,7 +510,7 @@ public async Task DeleteTableEntriesAsync(List<(T Entity, string ETag)> collecti
 
                 try
                 {
-                    Func<Task<List<(T Entity, string ETag)>>> executeQueryHandleContinuations = async () =>
+                    async Task<List<(T Entity, string ETag)>> executeQueryHandleContinuations()
                     {
                         var list = new List<(T, string)>();
                         var results = Table.QueryAsync<T>(filter);
@@ -520,7 +520,7 @@ public async Task DeleteTableEntriesAsync(List<(T Entity, string ETag)> collecti
                         }
 
                         return list;
-                    };
+                    }
 
 #if !ORLEANS_TRANSACTIONS
                     IBackoffProvider backoff = new FixedBackoff(this.StoragePolicyOptions.PauseBetweenOperationRetries);

src/Orleans.Core/Async/AsyncExecutorWithRetries.cs

@@ -44,7 +44,7 @@ public static Task ExecuteWithRetries(
             TimeSpan maxExecutionTime,
             IBackoffProvider onErrorBackOff)
         {
-            Func<int, Task<bool>> function = async (int i) => { await action(i); return true; };
+            async Task<bool> function(int i) { await action(i); return true; }
             return ExecuteWithRetriesHelper<bool>(
                 function,
                 0,

src/Orleans.Runtime/Catalog/ActivationCollector.cs

@@ -513,7 +513,7 @@ private async Task DeactivateActivationsFromCollector(List<ICollectibleGrainCont
             logger.LogInformation((int)ErrorCode.Catalog_ShutdownActivations_1, "DeactivateActivationsFromCollector: total {Count} to promptly Destroy.", list.Count);
             CatalogInstruments.ActiviationShutdownViaCollection();
 
-            Action<Task> signalCompletion = task => mtcs.SetOneResult();
+            void signalCompletion(Task task) => mtcs.SetOneResult();
             var reason = GetDeactivationReason();
             for (var i = 0; i < list.Count; i++)
             {

src/Orleans.Runtime/MembershipService/MembershipTableManager.cs

@@ -318,13 +318,13 @@ public async Task UpdateStatus(SiloStatus status)
 
             try
             {
-                Func<int, Task<bool>> updateMyStatusTask = async counter =>
+                async Task<bool> updateMyStatusTask(int counter)
                 {
                     numCalls++;
                     if (log.IsEnabled(LogLevel.Debug)) log.LogDebug("Going to try to TryUpdateMyStatusGlobalOnce #{Attempt}", counter);
                     return await TryUpdateMyStatusGlobalOnce(status);  // function to retry
-                };
-                
+                }
+
                 if (status == SiloStatus.Dead && this.membershipTableProvider is SystemTargetBasedMembershipTable)
                 {
                     // SystemTarget-based membership may not be accessible at this stage, so allow for one quick attempt to update

src/Orleans.TestingHost/Utils/TestingUtils.cs

@@ -80,20 +80,19 @@ public static async Task WaitUntilAsync(Func<bool,Task<bool>> predicate, TimeSpa
         {
             delayOnFail = delayOnFail ?? TimeSpan.FromSeconds(1);
             var keepGoing = new[] { true };
-            Func<Task> loop =
-                async () =>
+            async Task loop()
+            {
+                bool passed;
+                do
                 {
-                    bool passed;
-                    do
-                    {
-                        // need to wait a bit to before re-checking the condition.
-                        await Task.Delay(delayOnFail.Value);
-                        passed = await predicate(false);
-                    }
-                    while (!passed && keepGoing[0]);
-                    if(!passed)
-                        await predicate(true);
-                };
+                    // need to wait a bit to before re-checking the condition.
+                    await Task.Delay(delayOnFail.Value);
+                    passed = await predicate(false);
+                }
+                while (!passed && keepGoing[0]);
+                if (!passed)
+                    await predicate(true);
+            }
 
             var task = loop();
             try

src/Orleans.Transactions.TestKit.Base/Consistency/ConsistencyTestHarness.cs

@@ -146,14 +146,14 @@ public void CheckConsistency(bool tolerateGenericTimeouts = false, bool tolerate
             foreach (var grainKvp in tuples)
             {
                 var pos = 0;
-                Action<string> fail = (msg) =>
+                void fail(string msg)
                 {
                     foreach (var kvp1 in grainKvp.Value)
                         foreach (var kvp2 in kvp1.Value)
                             foreach (var r in kvp2.Value)
                                 output($"g{grainKvp.Key} v{kvp1.Key} w:{kvp2.Key} a:{r}");
                     true.Should().BeFalse(msg);
-                };
+                }
 
                 HashSet<string> readersOfPreviousVersion = new HashSet<string>();
 

src/Orleans.Transactions.TestKit.Base/TestRunners/TransactionRecoveryTestsRunner.cs

@@ -74,7 +74,7 @@ protected virtual async Task TransactionWillRecoverAfterRandomSiloFailure(string
         {
             var endOnCommand = new[] { false };
             var index = new[] { 0 };
-            Func<int> getIndex = () => index[0]++;
+            int getIndex() => index[0]++;
             List<ExpectedGrainActivity> txGrains = Enumerable.Range(0, concurrent * 2)
                 .Select(i => Guid.NewGuid())
                 .Select(grainId => new ExpectedGrainActivity(grainId, TestGrain<ITransactionalBitArrayGrain>(transactionTestGrainClassName, grainId)))

src/Orleans.Transactions/State/ReaderWriterLock.cs

@@ -138,7 +138,7 @@ public async Task<TResult> EnterLock<TResult>(Guid transactionId, DateTime prior
 
             var result =
                 new TaskCompletionSource<TResult>(TaskCreationOptions.RunContinuationsAsynchronously);
-            Action completion = () =>
+            void completion()
             {
                 try
                 {
@@ -148,7 +148,7 @@ public async Task<TResult> EnterLock<TResult>(Guid transactionId, DateTime prior
                 {
                     result.TrySetException(exception);
                 }
-            };
+            }
 
             if (group != currentGroup)
             {

src/Orleans.Transactions/State/TransactionalState.cs

@@ -212,7 +212,7 @@ internal async Task OnSetupState(Action<IGrainContext, string, TransactionQueue<
             ITransactionalStateStorage<TState> storage = storageFactory.Create<TState>(this.config.StorageName, this.config.StateName);
 
             // setup transaction processing pipe
-            Action deactivate = () => grainRuntime.DeactivateOnIdle(context);
+            void deactivate() => grainRuntime.DeactivateOnIdle(context);
             var options = this.context.ActivationServices.GetRequiredService<IOptions<TransactionalStateOptions>>();
             var clock = this.context.ActivationServices.GetRequiredService<IClock>();
             var timerManager = this.context.ActivationServices.GetRequiredService<ITimerManager>();

src/Orleans.Transactions/TOC/TransactionCommitter.cs

@@ -139,7 +139,7 @@ private async Task OnSetupState(CancellationToken ct)
             ITransactionalStateStorage<OperationState> storage = storageFactory.Create<OperationState>(this.config.StorageName, this.config.ServiceName);
 
             // setup transaction processing pipe
-            Action deactivate = () => grainRuntime.DeactivateOnIdle(context);
+            void deactivate() => grainRuntime.DeactivateOnIdle(context);
             var options = this.context.ActivationServices.GetRequiredService<IOptions<TransactionalStateOptions>>();
             var clock = this.context.ActivationServices.GetRequiredService<IClock>();
             TService service = this.context.ActivationServices.GetRequiredServiceByName<TService>(this.config.ServiceName);

test/Benchmarks/GrainStorage/GrainStorageBenchmark.cs

@@ -101,7 +101,7 @@ public async Task RunAsync()
         {
             Stopwatch sw = Stopwatch.StartNew();
             bool running = true;
-            Func<bool> isRunning = () => running;
+            bool isRunning() => running;
             var runTask = Task.WhenAll(Enumerable.Range(0, concurrent).Select(i => RunAsync(i, isRunning)).ToList());
             Task[] waitTasks = { runTask, Task.Delay(duration) };
             await Task.WhenAny(waitTasks);

test/Extensions/Consul.Tests/ConsulClusteringOptionsTests.cs

@@ -26,7 +26,7 @@ public void ThrowsArgumentNullExceptionIfCallbackIsNull()
             Func<IConsulClient> callback = null;
 
             // ensure we check the callback.
-            var shouldThrow = ()=> options.ConfigureConsulClient(callback);
+            void shouldThrow() => options.ConfigureConsulClient(callback);
 
             Assert.Throws<ArgumentNullException>(shouldThrow);
         }
@@ -36,7 +36,7 @@ public void WeCanInjectAConsulClient()
         {
             var fakeConsul = new FakeConsul();
             var options = new ConsulClusteringOptions();
-            Func<IConsulClient> callback = () => fakeConsul;
+            IConsulClient callback() => fakeConsul;
 
             //we can inject the consul
             options.ConfigureConsulClient(callback);

test/Extensions/ServiceBus.Tests/TestStreamProviders/EHStreamProviderForMonitorTests.cs

@@ -79,8 +79,8 @@ protected override IEventHubQueueCacheFactory CreateCacheFactory(EventHubStreamC
             var loggerFactory = this.serviceProvider.GetRequiredService<ILoggerFactory>();
             var eventHubPath = this.ehOptions.EventHubName;
             var sharedDimensions = new EventHubMonitorAggregationDimensions(eventHubPath);
-            Func<EventHubCacheMonitorDimensions, ILoggerFactory, ICacheMonitor> cacheMonitorFactory = (dimensions, logger) => this.cacheMonitorForTesting;
-            Func<EventHubBlockPoolMonitorDimensions, ILoggerFactory, IBlockPoolMonitor> blockPoolMonitorFactory = (dimensions, logger) => this.blockPoolMonitorForTesting;
+            ICacheMonitor cacheMonitorFactory(EventHubCacheMonitorDimensions dimensions, ILoggerFactory logger) => this.cacheMonitorForTesting;
+            IBlockPoolMonitor blockPoolMonitorFactory(EventHubBlockPoolMonitorDimensions dimensions, ILoggerFactory logger) => this.blockPoolMonitorForTesting;
             return new CacheFactoryForMonitorTesting(
                 this.cachePressureInjectionMonitor,
                 this.cacheOptions,

test/Extensions/TesterAzureUtils/AsyncPipelineTests.cs

@@ -114,37 +114,34 @@ private async Task AsyncPipelineBlackBoxConsistencyTest(int workerCount)
             int[] pipelineSize = { 0 };
             var capacityReached = new InterlockedFlag();
 
-            Action workFunc =
-                () =>
-                {
-                    var sz = Interlocked.Increment(ref pipelineSize[0]);
-                    CheckPipelineState(sz, pipelineCapacity, capacityReached);
-                    Task.Delay(delayLength).Wait();
-                    Interlocked.Decrement(ref pipelineSize[0]);
-                    Interlocked.Increment(ref tasksCompleted);
-                };
+            void workFunc()
+            {
+                var sz = Interlocked.Increment(ref pipelineSize[0]);
+                CheckPipelineState(sz, pipelineCapacity, capacityReached);
+                Task.Delay(delayLength).Wait();
+                Interlocked.Decrement(ref pipelineSize[0]);
+                Interlocked.Increment(ref tasksCompleted);
+            }
 
-            Action workerFunc =
-                () =>
+            void workerFunc()
+            {
+                for (var j = 0; j < loopCount; j++)
                 {
-                    for (var j = 0; j < loopCount; j++)
-                    {
-                        Task task = new Task(workFunc);
-                        pipeline.Add(task, whiteBox: null);
-                        task.Start();
-                    }
-                };
+                    Task task = new Task(workFunc);
+                    pipeline.Add(task, whiteBox: null);
+                    task.Start();
+                }
+            }
 
-            Func<Task> monitorFunc =
-                async () =>
+            async Task monitorFunc()
+            {
+                var delay = TimeSpan.FromSeconds(5);
+                while (tasksCompleted < expectedTasksCompleted)
                 {
-                    var delay = TimeSpan.FromSeconds(5);
-                    while (tasksCompleted < expectedTasksCompleted)
-                    {
-                        output.WriteLine("test in progress: tasksCompleted = {0}.", tasksCompleted);
-                        await Task.Delay(delay);
-                    }
-                };
+                    output.WriteLine("test in progress: tasksCompleted = {0}.", tasksCompleted);
+                    await Task.Delay(delay);
+                }
+            }
 
             var workers = new Task[workerCount];
             var stopwatch = Stopwatch.StartNew();

test/Grains/TestInternalGrains/ActivateDeactivateTestGrain.cs

@@ -247,37 +247,36 @@ public override async Task OnActivateAsync(CancellationToken cancellationToken)
                     });
             // we want to use Task.ContinueWith with an async lambda, an explicitly typed variable is required to avoid
             // writing code that doesn't do what i think it is doing.
-            Func<Task> asyncCont =
-                async () =>
-                {
-                    Assert.NotNull(TaskScheduler.Current);
-                    Assert.NotEqual(TaskScheduler.Current, TaskScheduler.Default);
-                    logger.LogInformation("Started-OnActivateAsync");
+            async Task asyncCont()
+            {
+                Assert.NotNull(TaskScheduler.Current);
+                Assert.NotEqual(TaskScheduler.Current, TaskScheduler.Default);
+                logger.LogInformation("Started-OnActivateAsync");
 
-                    Assert.True(doingActivate, "Doing Activate 1");
-                    Assert.False(doingDeactivate, "Not doing Deactivate");
+                Assert.True(doingActivate, "Doing Activate 1");
+                Assert.False(doingDeactivate, "Not doing Deactivate");
 
-                    try
-                    {
-                        logger.LogInformation("Calling RecordActivateCall");
-                        await watcher.RecordActivateCall(RuntimeHelpers.GetHashCode(this).ToString("X"));
-                        logger.LogInformation("Returned from calling RecordActivateCall");
-                    }
-                    catch (Exception exc)
-                    {
-                        logger.LogError(exc, "RecordActivateCall failed");
-                        Assert.True(false, "RecordActivateCall failed with error " + exc);
-                    }
+                try
+                {
+                    logger.LogInformation("Calling RecordActivateCall");
+                    await watcher.RecordActivateCall(RuntimeHelpers.GetHashCode(this).ToString("X"));
+                    logger.LogInformation("Returned from calling RecordActivateCall");
+                }
+                catch (Exception exc)
+                {
+                    logger.LogError(exc, "RecordActivateCall failed");
+                    Assert.True(false, "RecordActivateCall failed with error " + exc);
+                }
 
-                    Assert.True(doingActivate, "Doing Activate 2");
-                    Assert.False(doingDeactivate, "Not doing Deactivate");
+                Assert.True(doingActivate, "Doing Activate 2");
+                Assert.False(doingDeactivate, "Not doing Deactivate");
 
-                    await Task.Delay(TimeSpan.FromSeconds(1));
+                await Task.Delay(TimeSpan.FromSeconds(1));
 
-                    doingActivate = false;
+                doingActivate = false;
 
-                    logger.LogInformation("Finished-OnActivateAsync");
-                };
+                logger.LogInformation("Finished-OnActivateAsync");
+            }
             var awaitMe = startMe.ContinueWith(_ => asyncCont()).Unwrap();
             startMe.Start();
             await awaitMe;

test/Grains/TestInternalGrains/StreamingGrain.cs

@@ -265,10 +265,10 @@ public Task ProduceParallelSeries(int count)
             for (var i = 1; i <= count; ++i)
             {
                 int capture = i;
-                Func<Task<bool>> func = async () =>
-                    {
-                        return await ProduceItem($"parallel#{capture}");
-                    };
+                async Task<bool> func()
+                {
+                    return await ProduceItem($"parallel#{capture}");
+                }
                 // Need to call on different threads to force parallel execution.
                 tasks[capture - 1] = Task.Factory.StartNew(func).Unwrap();
             }

test/NonSilo.Tests/Membership/MembershipAgentTests.cs

@@ -129,7 +129,7 @@ Func<CancellationToken, Task> Callback(int level) => ct =>
                 levels[level] = this.manager.CurrentStatus;
                 return Task.CompletedTask;
             };
-            Func<CancellationToken, Task> NoOp = ct => Task.CompletedTask;
+            Task NoOp(CancellationToken ct) => Task.CompletedTask;
             foreach (var l in new[] {
                 ServiceLifecycleStage.RuntimeInitialize,
                 ServiceLifecycleStage.AfterRuntimeGrainServices,
@@ -171,7 +171,7 @@ Func<CancellationToken, Task> Callback(int level) => ct =>
                 levels[level] = this.manager.CurrentStatus;
                 return Task.CompletedTask;
             };
-            Func<CancellationToken, Task> NoOp = ct => Task.CompletedTask;
+            Task NoOp(CancellationToken ct) => Task.CompletedTask;
             foreach (var l in new[] {
                 ServiceLifecycleStage.RuntimeInitialize,
                 ServiceLifecycleStage.AfterRuntimeGrainServices,
@@ -271,7 +271,7 @@ public async Task MembershipAgent_LifecycleStages_ValidateInitialConnectivity_Su
                 Assert.True(await this.membershipTable.InsertRow(entry, table.Version.Next()));
             }
 
-            Func<SiloHealthMonitor, SiloHealthMonitor.ProbeResult, Task> onProbeResult = (siloHealthMonitor, probeResult) => Task.CompletedTask;
+            Task onProbeResult(SiloHealthMonitor siloHealthMonitor, SiloHealthMonitor.ProbeResult probeResult) => Task.CompletedTask;
 
             var clusterHealthMonitorTestAccessor = (ClusterHealthMonitor.ITestAccessor)this.clusterHealthMonitor;
             clusterHealthMonitorTestAccessor.CreateMonitor = silo => new SiloHealthMonitor(

test/NonSilo.Tests/Membership/SiloHealthMonitorTests.cs

@@ -79,7 +79,7 @@ public SiloHealthMonitorTests(ITestOutputHelper output)
             _optionsMonitor.CurrentValue.ReturnsForAnyArgs(info => _clusterMembershipOptions);
 
             _probeResults = Channel.CreateBounded<ProbeResult>(new BoundedChannelOptions(1) { FullMode = BoundedChannelFullMode.Wait });
-            Func<SiloHealthMonitor, ProbeResult, Task> onProbeResult = (mon, res) => _probeResults.Writer.WriteAsync(res).AsTask();
+            Task onProbeResult(SiloHealthMonitor mon, ProbeResult res) => _probeResults.Writer.WriteAsync(res).AsTask();
 
             _membershipSnapshot = Snapshot(
                 1,

test/NonSilo.Tests/SchedulerTests/OrleansTaskSchedulerAdvancedTests_Set2.cs

@@ -107,7 +107,7 @@ public void ActivationSched_SubTaskExecutionSequencing()
 
             int n = 0;
 
-            Action action = () =>
+            void action()
             {
                 LogContext("WorkItem-task " + Task.CurrentId);
 
@@ -134,7 +134,7 @@ public void ActivationSched_SubTaskExecutionSequencing()
                         this.output.WriteLine("Sub-task " + id + " Done");
                     });
                 }
-            };
+            }
 
             Task t = new Task(action);
 
@@ -705,7 +705,7 @@ internal async Task Run_ActivationSched_Test1(TaskScheduler scheduler, bool boun
 
                 Task t1 = grain.Test1();
 
-                Action wrappedDoneAction = () => { wrappedDone.SetResult(true); };
+                void wrappedDoneAction() { wrappedDone.SetResult(true); }
 
                 if (bounceToThreadPool)
                 {