diff --git a/src/Microsoft.Management.Infrastructure.CimCmdlets/CimSessionOperations.cs b/src/Microsoft.Management.Infrastructure.CimCmdlets/CimSessionOperations.cs
index 000fcfd206..8bae87bc6e 100644
--- a/src/Microsoft.Management.Infrastructure.CimCmdlets/CimSessionOperations.cs
+++ b/src/Microsoft.Management.Infrastructure.CimCmdlets/CimSessionOperations.cs
@@ -791,7 +791,7 @@ namespace Microsoft.Management.Infrastructure.CimCmdlets
         {
             this.sessionState = cimSessions.GetOrAdd(
                 CurrentRunspaceId,
-                delegate (Guid instanceId)
+                (Guid instanceId) =>
                 {
                     if (Runspace.DefaultRunspace != null)
                     {
diff --git a/src/Microsoft.PowerShell.Commands.Management/cimSupport/cmdletization/SessionBasedWrapper.cs b/src/Microsoft.PowerShell.Commands.Management/cimSupport/cmdletization/SessionBasedWrapper.cs
index 06dcc9150b..24b142a508 100644
--- a/src/Microsoft.PowerShell.Commands.Management/cimSupport/cmdletization/SessionBasedWrapper.cs
+++ b/src/Microsoft.PowerShell.Commands.Management/cimSupport/cmdletization/SessionBasedWrapper.cs
@@ -151,14 +151,15 @@ namespace Microsoft.PowerShell.Cmdletization
                     discardNonPipelineResults,
                     actionAgainstResults == null
                         ? (Action<PSObject>)null
-                        : delegate (PSObject pso)
-                              {
-                                  var objectInstance =
-                                      (TObjectInstance)
-                                      LanguagePrimitives.ConvertTo(pso, typeof(TObjectInstance),
-                                                                   CultureInfo.InvariantCulture);
-                                  actionAgainstResults(sessionForJob, objectInstance);
-                              });
+                        : ((PSObject pso) =>
+                        {
+                            var objectInstance =
+                                (TObjectInstance)LanguagePrimitives.ConvertTo(
+                                    pso,
+                                    typeof(TObjectInstance),
+                                    CultureInfo.InvariantCulture);
+                            actionAgainstResults(sessionForJob, objectInstance);
+                        }));
             }
 
             return queryJob;
@@ -239,7 +240,7 @@ namespace Microsoft.PowerShell.Cmdletization
         private void HandleJobOutput(Job job, TSession sessionForJob, bool discardNonPipelineResults, Action<PSObject> outputAction)
         {
             Action<PSObject> processOutput =
-                    delegate (PSObject pso)
+                    (PSObject pso) =>
                     {
                         if (pso == null)
                         {
@@ -250,7 +251,7 @@ namespace Microsoft.PowerShell.Cmdletization
                     };
 
             job.Output.DataAdded +=
-                    delegate (object sender, DataAddedEventArgs eventArgs)
+                    (object sender, DataAddedEventArgs eventArgs) =>
                     {
                         var dataCollection = (PSDataCollection<PSObject>)sender;
 
@@ -300,7 +301,7 @@ namespace Microsoft.PowerShell.Cmdletization
         private static void DiscardJobOutputs<T>(PSDataCollection<T> psDataCollection)
         {
             psDataCollection.DataAdded +=
-                    delegate (object sender, DataAddedEventArgs e)
+                    (object sender, DataAddedEventArgs e) =>
                     {
                         var localDataCollection = (PSDataCollection<T>)sender;
                         localDataCollection.Clear();
@@ -409,7 +410,7 @@ namespace Microsoft.PowerShell.Cmdletization
                 StartableJob queryJob = this.DoCreateQueryJob(
                     sessionForJob,
                     query,
-                    delegate (TSession sessionForMethodInvocationJob, TObjectInstance objectInstance)
+                    (TSession sessionForMethodInvocationJob, TObjectInstance objectInstance) =>
                     {
                         StartableJob methodInvocationJob = this.DoCreateInstanceMethodInvocationJob(
                             sessionForMethodInvocationJob,
diff --git a/src/Microsoft.PowerShell.Commands.Management/cimSupport/cmdletization/cim/TerminatingErrorTracker.cs b/src/Microsoft.PowerShell.Commands.Management/cimSupport/cmdletization/cim/TerminatingErrorTracker.cs
index 730e54a639..73b8d0f301 100644
--- a/src/Microsoft.PowerShell.Commands.Management/cimSupport/cmdletization/cim/TerminatingErrorTracker.cs
+++ b/src/Microsoft.PowerShell.Commands.Management/cimSupport/cmdletization/cim/TerminatingErrorTracker.cs
@@ -175,11 +175,11 @@ namespace Microsoft.PowerShell.Cmdletization.Cim
                 key: terminatedSession,
                 addValue: true,
                 updateValueFactory:
-                    delegate (CimSession key, bool isTerminatedValueInDictionary)
-                        {
-                            closureSafeSessionWasAlreadyTerminated = isTerminatedValueInDictionary;
-                            return true;
-                        });
+                    (CimSession key, bool isTerminatedValueInDictionary) =>
+                    {
+                        closureSafeSessionWasAlreadyTerminated = isTerminatedValueInDictionary;
+                        return true;
+                    });
 
             sessionWasAlreadyTerminated = closureSafeSessionWasAlreadyTerminated;
         }
@@ -198,20 +198,20 @@ namespace Microsoft.PowerShell.Cmdletization.Cim
         {
             ManualResetEventSlim manualResetEventSlim = new ManualResetEventSlim();
             object lockObject = new object();
-            Func<Cmdlet, bool> action = delegate (Cmdlet cmdlet)
-                                                {
-                                                    _numberOfReportedSessionTerminatingErrors++;
-                                                    if (_numberOfReportedSessionTerminatingErrors >= _numberOfSessions)
-                                                    {
-                                                        cmdlet.ThrowTerminatingError(errorRecord);
-                                                    }
-                                                    else
-                                                    {
-                                                        cmdlet.WriteError(errorRecord);
-                                                    }
+            Func<Cmdlet, bool> action = (Cmdlet cmdlet) =>
+            {
+                _numberOfReportedSessionTerminatingErrors++;
+                if (_numberOfReportedSessionTerminatingErrors >= _numberOfSessions)
+                {
+                    cmdlet.ThrowTerminatingError(errorRecord);
+                }
+                else
+                {
+                    cmdlet.WriteError(errorRecord);
+                }
 
-                                                    return false; // not really needed here, but required by CmdletMethodInvoker
-                                                };
+                return false; // not really needed here, but required by CmdletMethodInvoker
+            };
 
             return new CmdletMethodInvoker<bool>
             {
diff --git a/src/Microsoft.PowerShell.Commands.Management/cimSupport/cmdletization/cim/cimConverter.cs b/src/Microsoft.PowerShell.Commands.Management/cimSupport/cmdletization/cim/cimConverter.cs
index 033b881353..915fb02e49 100644
--- a/src/Microsoft.PowerShell.Commands.Management/cimSupport/cmdletization/cim/cimConverter.cs
+++ b/src/Microsoft.PowerShell.Commands.Management/cimSupport/cmdletization/cim/cimConverter.cs
@@ -399,21 +399,21 @@ namespace Microsoft.PowerShell.Cim
                 return dotNetObject;
             }
 
-            Func<Func<object>, object> exceptionSafeReturn = delegate (Func<object> innerAction)
-                                                                 {
-                                                                     try
-                                                                     {
-                                                                         return innerAction();
-                                                                     }
-                                                                     catch (Exception e)
-                                                                     {
-                                                                         throw CimValueConverter.GetInvalidCastException(
-                                                                             e,
-                                                                             "InvalidCimToDotNetCast",
-                                                                             cimObject,
-                                                                             expectedDotNetType.FullName);
-                                                                     }
-                                                                 };
+            Func<Func<object>, object> exceptionSafeReturn = (Func<object> innerAction) =>
+            {
+                try
+                {
+                    return innerAction();
+                }
+                catch (Exception e)
+                {
+                    throw CimValueConverter.GetInvalidCastException(
+                        e,
+                        "InvalidCimToDotNetCast",
+                        cimObject,
+                        expectedDotNetType.FullName);
+                }
+            };
 
             if (typeof(ObjectSecurity).IsAssignableFrom(expectedDotNetType))
             {
diff --git a/src/Microsoft.PowerShell.Commands.Utility/commands/utility/Get-PSBreakpoint.cs b/src/Microsoft.PowerShell.Commands.Utility/commands/utility/Get-PSBreakpoint.cs
index b2680912df..133c03646f 100644
--- a/src/Microsoft.PowerShell.Commands.Utility/commands/utility/Get-PSBreakpoint.cs
+++ b/src/Microsoft.PowerShell.Commands.Utility/commands/utility/Get-PSBreakpoint.cs
@@ -107,18 +107,14 @@ namespace Microsoft.PowerShell.Commands
                 breakpoints = Filter(
                     breakpoints,
                     Id,
-                    delegate (Breakpoint breakpoint, int id)
-                    {
-                        return breakpoint.Id == id;
-                    }
-                );
+                    (Breakpoint breakpoint, int id) => breakpoint.Id == id);
             }
             else if (ParameterSetName.Equals(CommandParameterSetName, StringComparison.OrdinalIgnoreCase))
             {
                 breakpoints = Filter(
                     breakpoints,
                     Command,
-                    delegate (Breakpoint breakpoint, string command)
+                    (Breakpoint breakpoint, string command) =>
                     {
                         if (!(breakpoint is CommandBreakpoint commandBreakpoint))
                         {
@@ -133,7 +129,7 @@ namespace Microsoft.PowerShell.Commands
                 breakpoints = Filter(
                     breakpoints,
                     Variable,
-                    delegate (Breakpoint breakpoint, string variable)
+                    (Breakpoint breakpoint, string variable) =>
                     {
                         if (!(breakpoint is VariableBreakpoint variableBreakpoint))
                         {
@@ -148,7 +144,7 @@ namespace Microsoft.PowerShell.Commands
                 breakpoints = Filter(
                     breakpoints,
                     Type,
-                    delegate (Breakpoint breakpoint, BreakpointType type)
+                    (Breakpoint breakpoint, BreakpointType type) =>
                     {
                         switch (type)
                         {
@@ -191,7 +187,7 @@ namespace Microsoft.PowerShell.Commands
                 breakpoints = Filter(
                     breakpoints,
                     Script,
-                    delegate (Breakpoint breakpoint, string script)
+                    (Breakpoint breakpoint, string script) =>
                     {
                         if (breakpoint.Script == null)
                         {
diff --git a/src/Microsoft.PowerShell.Commands.Utility/commands/utility/GetAliasCommand.cs b/src/Microsoft.PowerShell.Commands.Utility/commands/utility/GetAliasCommand.cs
index 49baa9bd29..e44179440c 100644
--- a/src/Microsoft.PowerShell.Commands.Utility/commands/utility/GetAliasCommand.cs
+++ b/src/Microsoft.PowerShell.Commands.Utility/commands/utility/GetAliasCommand.cs
@@ -181,10 +181,7 @@ namespace Microsoft.PowerShell.Commands
             }
 
             results.Sort(
-                delegate (AliasInfo left, AliasInfo right)
-                {
-                    return StringComparer.CurrentCultureIgnoreCase.Compare(left.Name, right.Name);
-                });
+                (AliasInfo left, AliasInfo right) => StringComparer.CurrentCultureIgnoreCase.Compare(left.Name, right.Name));
             foreach (AliasInfo alias in results)
             {
                 this.WriteObject(alias);
diff --git a/src/Microsoft.PowerShell.Commands.Utility/commands/utility/ImplicitRemotingCommands.cs b/src/Microsoft.PowerShell.Commands.Utility/commands/utility/ImplicitRemotingCommands.cs
index 7433493257..80685cfaa3 100644
--- a/src/Microsoft.PowerShell.Commands.Utility/commands/utility/ImplicitRemotingCommands.cs
+++ b/src/Microsoft.PowerShell.Commands.Utility/commands/utility/ImplicitRemotingCommands.cs
@@ -1046,7 +1046,7 @@ namespace Microsoft.PowerShell.Commands
         {
             if (itemRehydrator == null)
             {
-                itemRehydrator = delegate (PSObject pso) { return ConvertTo<T>(commandName, pso); };
+                itemRehydrator = (PSObject pso) => ConvertTo<T>(commandName, pso);
             }
 
             List<T> result = null;
@@ -1073,7 +1073,7 @@ namespace Microsoft.PowerShell.Commands
 
             if (valueRehydrator == null)
             {
-                valueRehydrator = delegate (PSObject pso) { return ConvertTo<V>(commandName, pso); };
+                valueRehydrator = (PSObject pso) => ConvertTo<V>(commandName, pso);
             }
 
             Dictionary<K, V> result = new Dictionary<K, V>();
diff --git a/src/Microsoft.PowerShell.Commands.Utility/commands/utility/Var.cs b/src/Microsoft.PowerShell.Commands.Utility/commands/utility/Var.cs
index fd121fc5fb..1f18ee1b95 100644
--- a/src/Microsoft.PowerShell.Commands.Utility/commands/utility/Var.cs
+++ b/src/Microsoft.PowerShell.Commands.Utility/commands/utility/Var.cs
@@ -337,10 +337,7 @@ namespace Microsoft.PowerShell.Commands
                     GetMatchingVariables(varName, Scope, out wasFiltered, /*quiet*/ false);
 
                 matchingVariables.Sort(
-                    delegate (PSVariable left, PSVariable right)
-                    {
-                        return StringComparer.CurrentCultureIgnoreCase.Compare(left.Name, right.Name);
-                    });
+                    (PSVariable left, PSVariable right) => StringComparer.CurrentCultureIgnoreCase.Compare(left.Name, right.Name));
 
                 bool matchFound = false;
                 foreach (PSVariable matchingVariable in matchingVariables)
diff --git a/src/System.Management.Automation/engine/CommandCompletion/CommandCompletion.cs b/src/System.Management.Automation/engine/CommandCompletion/CommandCompletion.cs
index ce696f6303..8b12419488 100644
--- a/src/System.Management.Automation/engine/CommandCompletion/CommandCompletion.cs
+++ b/src/System.Management.Automation/engine/CommandCompletion/CommandCompletion.cs
@@ -1137,11 +1137,11 @@ namespace System.Management.Automation
                     return null;
                 }
 
-                result.Sort(delegate (PathItemAndConvertedPath x, PathItemAndConvertedPath y)
-                                {
-                                    Diagnostics.Assert(x.Path != null && y.Path != null, "SafeToString always returns a non-null string");
-                                    return string.Compare(x.Path, y.Path, StringComparison.CurrentCultureIgnoreCase);
-                                });
+                result.Sort((PathItemAndConvertedPath x, PathItemAndConvertedPath y) =>
+                {
+                    Diagnostics.Assert(x.Path != null && y.Path != null, "SafeToString always returns a non-null string");
+                    return string.Compare(x.Path, y.Path, StringComparison.CurrentCultureIgnoreCase);
+                });
 
                 return result;
             }
diff --git a/src/System.Management.Automation/engine/ErrorPackage.cs b/src/System.Management.Automation/engine/ErrorPackage.cs
index 565f26c9a6..d35130092f 100644
--- a/src/System.Management.Automation/engine/ErrorPackage.cs
+++ b/src/System.Management.Automation/engine/ErrorPackage.cs
@@ -1204,21 +1204,21 @@ namespace System.Management.Automation
 
         private void ToPSObjectForRemoting(PSObject dest, bool serializeExtInfo)
         {
-            RemotingEncoder.AddNoteProperty<Exception>(dest, "Exception", delegate () { return Exception; });
-            RemotingEncoder.AddNoteProperty<object>(dest, "TargetObject", delegate () { return TargetObject; });
-            RemotingEncoder.AddNoteProperty<string>(dest, "FullyQualifiedErrorId", delegate () { return FullyQualifiedErrorId; });
-            RemotingEncoder.AddNoteProperty<InvocationInfo>(dest, "InvocationInfo", delegate () { return InvocationInfo; });
-            RemotingEncoder.AddNoteProperty<int>(dest, "ErrorCategory_Category", delegate () { return (int)CategoryInfo.Category; });
-            RemotingEncoder.AddNoteProperty<string>(dest, "ErrorCategory_Activity", delegate () { return CategoryInfo.Activity; });
-            RemotingEncoder.AddNoteProperty<string>(dest, "ErrorCategory_Reason", delegate () { return CategoryInfo.Reason; });
-            RemotingEncoder.AddNoteProperty<string>(dest, "ErrorCategory_TargetName", delegate () { return CategoryInfo.TargetName; });
-            RemotingEncoder.AddNoteProperty<string>(dest, "ErrorCategory_TargetType", delegate () { return CategoryInfo.TargetType; });
-            RemotingEncoder.AddNoteProperty<string>(dest, "ErrorCategory_Message", delegate () { return CategoryInfo.GetMessage(CultureInfo.CurrentCulture); });
+            RemotingEncoder.AddNoteProperty<Exception>(dest, "Exception", () => Exception);
+            RemotingEncoder.AddNoteProperty<object>(dest, "TargetObject", () => TargetObject);
+            RemotingEncoder.AddNoteProperty<string>(dest, "FullyQualifiedErrorId", () => FullyQualifiedErrorId);
+            RemotingEncoder.AddNoteProperty<InvocationInfo>(dest, "InvocationInfo", () => InvocationInfo);
+            RemotingEncoder.AddNoteProperty<int>(dest, "ErrorCategory_Category", () => (int)CategoryInfo.Category);
+            RemotingEncoder.AddNoteProperty<string>(dest, "ErrorCategory_Activity", () => CategoryInfo.Activity);
+            RemotingEncoder.AddNoteProperty<string>(dest, "ErrorCategory_Reason", () => CategoryInfo.Reason);
+            RemotingEncoder.AddNoteProperty<string>(dest, "ErrorCategory_TargetName", () => CategoryInfo.TargetName);
+            RemotingEncoder.AddNoteProperty<string>(dest, "ErrorCategory_TargetType", () => CategoryInfo.TargetType);
+            RemotingEncoder.AddNoteProperty<string>(dest, "ErrorCategory_Message", () => CategoryInfo.GetMessage(CultureInfo.CurrentCulture));
 
             if (ErrorDetails != null)
             {
-                RemotingEncoder.AddNoteProperty<string>(dest, "ErrorDetails_Message", delegate () { return ErrorDetails.Message; });
-                RemotingEncoder.AddNoteProperty<string>(dest, "ErrorDetails_RecommendedAction", delegate () { return ErrorDetails.RecommendedAction; });
+                RemotingEncoder.AddNoteProperty<string>(dest, "ErrorDetails_Message", () => ErrorDetails.Message);
+                RemotingEncoder.AddNoteProperty<string>(dest, "ErrorDetails_RecommendedAction", () => ErrorDetails.RecommendedAction);
             }
 
             if (!serializeExtInfo || this.InvocationInfo == null)
@@ -1229,12 +1229,12 @@ namespace System.Management.Automation
             {
                 RemotingEncoder.AddNoteProperty(dest, "SerializeExtendedInfo", () => true);
                 this.InvocationInfo.ToPSObjectForRemoting(dest);
-                RemotingEncoder.AddNoteProperty<object>(dest, "PipelineIterationInfo", delegate () { return PipelineIterationInfo; });
+                RemotingEncoder.AddNoteProperty<object>(dest, "PipelineIterationInfo", () => PipelineIterationInfo);
             }
 
             if (!string.IsNullOrEmpty(this.ScriptStackTrace))
             {
-                RemotingEncoder.AddNoteProperty(dest, "ErrorDetails_ScriptStackTrace", delegate () { return this.ScriptStackTrace; });
+                RemotingEncoder.AddNoteProperty(dest, "ErrorDetails_ScriptStackTrace", () => this.ScriptStackTrace);
             }
         }
 
diff --git a/src/System.Management.Automation/engine/EventManager.cs b/src/System.Management.Automation/engine/EventManager.cs
index 83e48d6481..c4e5760fd5 100644
--- a/src/System.Management.Automation/engine/EventManager.cs
+++ b/src/System.Management.Automation/engine/EventManager.cs
@@ -953,11 +953,7 @@ namespace System.Management.Automation
             }
             else
             {
-                ThreadPool.QueueUserWorkItem(new WaitCallback(
-                    delegate (object unused)
-                    {
-                        ProcessNewEventImplementation(newEvent, false);
-                    }));
+                ThreadPool.QueueUserWorkItem(new WaitCallback((_) => ProcessNewEventImplementation(newEvent, false)));
             }
         }
 
@@ -1137,7 +1133,7 @@ namespace System.Management.Automation
                     // teardown event. That can result in starvation of
                     // foreground threads that also want to use the runspace.
                     ThreadPool.QueueUserWorkItem(new WaitCallback(
-                        delegate (object unused)
+                        (_) =>
                         {
                             System.Threading.Thread.Sleep(100);
                             this.PulseEngine();
diff --git a/src/System.Management.Automation/engine/InitialSessionState.cs b/src/System.Management.Automation/engine/InitialSessionState.cs
index 406b7d9541..8d9b01ad13 100644
--- a/src/System.Management.Automation/engine/InitialSessionState.cs
+++ b/src/System.Management.Automation/engine/InitialSessionState.cs
@@ -45,10 +45,7 @@ namespace System.Management.Automation.Runspaces
             // We shouldn't create too many tasks.
 #if !UNIX
             // Amsi initialize can be a little slow
-            Task.Run(() =>
-            {
-                AmsiUtils.WinScanContent(content: string.Empty, sourceMetadata: string.Empty, warmUp: true);
-            });
+            Task.Run(() => AmsiUtils.WinScanContent(content: string.Empty, sourceMetadata: string.Empty, warmUp: true));
 #endif
 
             // One other task for other stuff that's faster, but still a little slow.
diff --git a/src/System.Management.Automation/engine/InternalCommands.cs b/src/System.Management.Automation/engine/InternalCommands.cs
index 9ac1c78c9b..0928cc8a0d 100644
--- a/src/System.Management.Automation/engine/InternalCommands.cs
+++ b/src/System.Management.Automation/engine/InternalCommands.cs
@@ -455,10 +455,7 @@ namespace Microsoft.PowerShell.Commands
             _taskCollection = new PSDataCollection<System.Management.Automation.PSTasks.PSTask>();
             _taskDataStreamWriter = new PSTaskDataStreamWriter(this);
             _taskPool = new PSTaskPool(ThrottleLimit, UseNewRunspace);
-            _taskPool.PoolComplete += (sender, args) =>
-            {
-                _taskDataStreamWriter.Close();
-            };
+            _taskPool.PoolComplete += (sender, args) => _taskDataStreamWriter.Close();
 
             // Create timeout timer if requested.
             if (TimeoutSeconds != 0)
diff --git a/src/System.Management.Automation/engine/Modules/ImportModuleCommand.cs b/src/System.Management.Automation/engine/Modules/ImportModuleCommand.cs
index 91ad11b216..44e6aea3f5 100644
--- a/src/System.Management.Automation/engine/Modules/ImportModuleCommand.cs
+++ b/src/System.Management.Automation/engine/Modules/ImportModuleCommand.cs
@@ -1823,11 +1823,11 @@ namespace Microsoft.PowerShell.Commands
                     ApplicationInsightsTelemetry.SendTelemetryMetric(TelemetryType.ModuleLoad, module.Name);
                     RemoteDiscoveryHelper.DispatchModuleInfoProcessing(
                         module,
-                        localAction: delegate ()
-                                         {
-                                             ImportModule_ViaLocalModuleInfo(importModuleOptions, module);
-                                             SetModuleBaseForEngineModules(module.Name, this.Context);
-                                         },
+                        localAction: () =>
+                        {
+                            ImportModule_ViaLocalModuleInfo(importModuleOptions, module);
+                            SetModuleBaseForEngineModules(module.Name, this.Context);
+                        },
 
                         cimSessionAction: (cimSession, resourceUri, cimNamespace) => ImportModule_RemotelyViaCimSession(
                             importModuleOptions,
diff --git a/src/System.Management.Automation/engine/Modules/ModuleIntrinsics.cs b/src/System.Management.Automation/engine/Modules/ModuleIntrinsics.cs
index b20e11e474..71f8633286 100644
--- a/src/System.Management.Automation/engine/Modules/ModuleIntrinsics.cs
+++ b/src/System.Management.Automation/engine/Modules/ModuleIntrinsics.cs
@@ -1450,7 +1450,7 @@ namespace System.Management.Automation
             Dbg.Assert(input != null, "Caller should verify that input != null");
 
             input.Sort(
-                delegate (T x, T y)
+                (T x, T y) =>
                 {
                     string kx = keyGetter(x);
                     string ky = keyGetter(y);
@@ -1527,7 +1527,7 @@ namespace System.Management.Automation
                     }
                 }
 
-                SortAndRemoveDuplicates(sessionState.ExportedFunctions, delegate (FunctionInfo ci) { return ci.Name; });
+                SortAndRemoveDuplicates(sessionState.ExportedFunctions, (FunctionInfo ci) => ci.Name);
             }
 
             if (cmdletPatterns != null)
@@ -1582,7 +1582,7 @@ namespace System.Management.Automation
                     }
                 }
 
-                SortAndRemoveDuplicates(sessionState.Module.CompiledExports, delegate (CmdletInfo ci) { return ci.Name; });
+                SortAndRemoveDuplicates(sessionState.Module.CompiledExports, (CmdletInfo ci) => ci.Name);
             }
 
             if (variablePatterns != null)
@@ -1605,7 +1605,7 @@ namespace System.Management.Automation
                     }
                 }
 
-                SortAndRemoveDuplicates(sessionState.ExportedVariables, delegate (PSVariable v) { return v.Name; });
+                SortAndRemoveDuplicates(sessionState.ExportedVariables, (PSVariable v) => v.Name);
             }
 
             if (aliasPatterns != null)
@@ -1645,7 +1645,7 @@ namespace System.Management.Automation
                     }
                 }
 
-                SortAndRemoveDuplicates(sessionState.ExportedAliases, delegate (AliasInfo ci) { return ci.Name; });
+                SortAndRemoveDuplicates(sessionState.ExportedAliases, (AliasInfo ci) => ci.Name);
             }
         }
 
diff --git a/src/System.Management.Automation/engine/Modules/NewModuleManifestCommand.cs b/src/System.Management.Automation/engine/Modules/NewModuleManifestCommand.cs
index eb0db3ba77..a1907a034a 100644
--- a/src/System.Management.Automation/engine/Modules/NewModuleManifestCommand.cs
+++ b/src/System.Management.Automation/engine/Modules/NewModuleManifestCommand.cs
@@ -1188,7 +1188,7 @@ namespace Microsoft.PowerShell.Commands
                 BuildModuleManifest(result, nameof(IconUri), Modules.IconUri, IconUri != null, () => QuoteName(IconUri), streamWriter);
                 BuildModuleManifest(result, nameof(ReleaseNotes), Modules.ReleaseNotes, !string.IsNullOrEmpty(ReleaseNotes), () => QuoteName(ReleaseNotes), streamWriter);
                 BuildModuleManifest(result, nameof(Prerelease), Modules.Prerelease, !string.IsNullOrEmpty(Prerelease), () => QuoteName(Prerelease), streamWriter);
-                BuildModuleManifest(result, nameof(RequireLicenseAcceptance), Modules.RequireLicenseAcceptance, RequireLicenseAcceptance.IsPresent, () => { return RequireLicenseAcceptance.IsPresent ? "$true" : "$false"; }, streamWriter);
+                BuildModuleManifest(result, nameof(RequireLicenseAcceptance), Modules.RequireLicenseAcceptance, RequireLicenseAcceptance.IsPresent, () => RequireLicenseAcceptance.IsPresent ? "$true" : "$false", streamWriter);
                 BuildModuleManifest(result, nameof(ExternalModuleDependencies), Modules.ExternalModuleDependencies, ExternalModuleDependencies != null && ExternalModuleDependencies.Length > 0, () => QuoteNames(ExternalModuleDependencies, streamWriter), streamWriter);
 
                 result.Append("    } ");
diff --git a/src/System.Management.Automation/engine/Modules/RemoteDiscoveryHelper.cs b/src/System.Management.Automation/engine/Modules/RemoteDiscoveryHelper.cs
index d6f4d9b7fe..65c2931db0 100644
--- a/src/System.Management.Automation/engine/Modules/RemoteDiscoveryHelper.cs
+++ b/src/System.Management.Automation/engine/Modules/RemoteDiscoveryHelper.cs
@@ -112,24 +112,24 @@ namespace System.Management.Automation
         private static EventHandler<DataAddedEventArgs> GetStreamForwarder<T>(Action<T> forwardingAction, bool swallowInvalidOperationExceptions = false)
         {
             // TODO/FIXME: ETW event for extended semantics streams
-            return delegate (object sender, DataAddedEventArgs eventArgs)
-                       {
-                           var psDataCollection = (PSDataCollection<T>)sender;
-                           foreach (T t in psDataCollection.ReadAll())
-                           {
-                               try
-                               {
-                                   forwardingAction(t);
-                               }
-                               catch (InvalidOperationException)
-                               {
-                                   if (!swallowInvalidOperationExceptions)
-                                   {
-                                       throw;
-                                   }
-                               }
-                           }
-                       };
+            return (object sender, DataAddedEventArgs eventArgs) =>
+            {
+                var psDataCollection = (PSDataCollection<T>)sender;
+                foreach (T t in psDataCollection.ReadAll())
+                {
+                    try
+                    {
+                        forwardingAction(t);
+                    }
+                    catch (InvalidOperationException)
+                    {
+                        if (!swallowInvalidOperationExceptions)
+                        {
+                            throw;
+                        }
+                    }
+                }
+            };
         }
 
         // This is a static field (instead of a constant) to make it possible to set through tests (and/or by customers if needed for a workaround)
@@ -151,7 +151,7 @@ namespace System.Management.Automation
 
                 EventHandler<DataAddedEventArgs> errorHandler = GetStreamForwarder<ErrorRecord>(
                     errorRecord => mergedOutput.Add(
-                        delegate (PSCmdlet c)
+                        (PSCmdlet c) =>
                         {
                             errorRecord = GetErrorRecordForRemotePipelineInvocation(errorRecord, errorMessageTemplate);
                             HandleErrorFromPipeline(c, errorRecord, powerShell);
@@ -161,7 +161,7 @@ namespace System.Management.Automation
 
                 EventHandler<DataAddedEventArgs> warningHandler = GetStreamForwarder<WarningRecord>(
                     warningRecord => mergedOutput.Add(
-                        delegate (PSCmdlet c)
+                        (PSCmdlet c) =>
                         {
                             c.WriteWarning(warningRecord.Message);
                             return Enumerable.Empty<PSObject>();
@@ -170,7 +170,7 @@ namespace System.Management.Automation
 
                 EventHandler<DataAddedEventArgs> verboseHandler = GetStreamForwarder<VerboseRecord>(
                     verboseRecord => mergedOutput.Add(
-                        delegate (PSCmdlet c)
+                        (PSCmdlet c) =>
                         {
                             c.WriteVerbose(verboseRecord.Message);
                             return Enumerable.Empty<PSObject>();
@@ -179,7 +179,7 @@ namespace System.Management.Automation
 
                 EventHandler<DataAddedEventArgs> debugHandler = GetStreamForwarder<DebugRecord>(
                     debugRecord => mergedOutput.Add(
-                        delegate (PSCmdlet c)
+                        (PSCmdlet c) =>
                         {
                             c.WriteDebug(debugRecord.Message);
                             return Enumerable.Empty<PSObject>();
@@ -188,7 +188,7 @@ namespace System.Management.Automation
 
                 EventHandler<DataAddedEventArgs> informationHandler = GetStreamForwarder<InformationRecord>(
                     informationRecord => mergedOutput.Add(
-                        delegate (PSCmdlet c)
+                        (PSCmdlet c) =>
                         {
                             c.WriteInformation(informationRecord);
                             return Enumerable.Empty<PSObject>();
@@ -262,7 +262,7 @@ namespace System.Management.Automation
             CancellationToken cancellationToken)
         {
             EventHandler<DataAddedEventArgs> errorHandler = GetStreamForwarder<ErrorRecord>(
-                delegate (ErrorRecord errorRecord)
+                (ErrorRecord errorRecord) =>
                 {
                     errorRecord = GetErrorRecordForRemotePipelineInvocation(errorRecord, errorMessageTemplate);
                     HandleErrorFromPipeline(cmdlet, errorRecord, powerShell);
@@ -486,7 +486,7 @@ namespace System.Management.Automation
 
             return EnumerateWithCatch(
                 outputStream,
-                delegate (Exception exception)
+                (Exception exception) =>
                 {
                     ErrorRecord errorRecord = GetErrorRecordForRemotePipelineInvocation(exception, errorMessageTemplate);
                     HandleErrorFromPipeline(cmdlet, errorRecord, powerShell);
@@ -801,7 +801,7 @@ namespace System.Management.Automation
             if (!onlyManifests)
             {
                 cimModules = cimModules.Select(
-                    delegate (CimModule cimModule)
+                    (CimModule cimModule) =>
                     {
                         cimModule.FetchAllModuleFiles(cimSession, cimNamespace, options);
                         return cimModule;
@@ -810,7 +810,7 @@ namespace System.Management.Automation
 
             return EnumerateWithCatch(
                 cimModules,
-                delegate (Exception exception)
+                (Exception exception) =>
                 {
                     ErrorRecord errorRecord = GetErrorRecordForRemoteDiscoveryProvider(exception);
                     if (!cmdlet.MyInvocation.ExpectingInput)
diff --git a/src/System.Management.Automation/engine/Modules/ScriptAnalysis.cs b/src/System.Management.Automation/engine/Modules/ScriptAnalysis.cs
index 27d72d02b1..4db13309f6 100644
--- a/src/System.Management.Automation/engine/Modules/ScriptAnalysis.cs
+++ b/src/System.Management.Automation/engine/Modules/ScriptAnalysis.cs
@@ -335,10 +335,7 @@ namespace System.Management.Automation
 
                 List<string> commandsToPostFilter = new List<string>();
 
-                Action<string> onEachCommand = importedCommandName =>
-                {
-                    commandsToPostFilter.Add(importedCommandName);
-                };
+                Action<string> onEachCommand = importedCommandName => commandsToPostFilter.Add(importedCommandName);
 
                 // Process any exports from the module that we determine from
                 // the -Function, -Cmdlet, or -Alias parameters
diff --git a/src/System.Management.Automation/engine/ParameterSetInfo.cs b/src/System.Management.Automation/engine/ParameterSetInfo.cs
index ef0fe9673a..c5b69dc554 100644
--- a/src/System.Management.Automation/engine/ParameterSetInfo.cs
+++ b/src/System.Management.Automation/engine/ParameterSetInfo.cs
@@ -92,20 +92,20 @@ namespace System.Management.Automation
             Text.StringBuilder result = new Text.StringBuilder();
 
             GenerateParametersInDisplayOrder(
-                                 parameter => AppendFormatCommandParameterInfo(parameter, result),
-                                 delegate (string str)
-                                     {
-                                         if (result.Length > 0)
-                                         {
-                                             result.Append(' ');
-                                         }
+                parameter => AppendFormatCommandParameterInfo(parameter, result),
+                (string str) =>
+                {
+                    if (result.Length > 0)
+                    {
+                        result.Append(' ');
+                    }
 
-                                         result.Append('[');
-                                         result.Append(str);
-                                         result.Append(']');
-                                     });
+                    result.Append('[');
+                    result.Append(str);
+                    result.Append(']');
+                });
 
-            return result.ToString();
+          return result.ToString();
         }
 
         /// <summary>
diff --git a/src/System.Management.Automation/engine/debugger/debugger.cs b/src/System.Management.Automation/engine/debugger/debugger.cs
index d56bd43e5c..a32276bcc7 100644
--- a/src/System.Management.Automation/engine/debugger/debugger.cs
+++ b/src/System.Management.Automation/engine/debugger/debugger.cs
@@ -4861,19 +4861,18 @@ namespace System.Management.Automation
 
                 StatementAst debugStatement = null;
                 StatementAst callingStatement = _parentScriptBlockAst.Find(
-                    ast =>
-                    { return ((ast is StatementAst) && (ast.Extent.StartLineNumber == callingLineNumber)); }
-
-                    , true) as StatementAst;
+                    ast => ast is StatementAst && (ast.Extent.StartLineNumber == callingLineNumber), true) as StatementAst;
 
                 if (callingStatement != null)
                 {
                     // Find first statement in calling statement.
-                    StatementAst firstStatement = callingStatement.Find(ast => { return ((ast is StatementAst) && ast.Extent.StartLineNumber > callingLineNumber); }, true) as StatementAst;
+                    StatementAst firstStatement = callingStatement.Find(
+                        ast => ast is StatementAst && ast.Extent.StartLineNumber > callingLineNumber, true) as StatementAst;
                     if (firstStatement != null)
                     {
                         int adjustedLineNumber = firstStatement.Extent.StartLineNumber + debugLineNumber - 1;
-                        debugStatement = callingStatement.Find(ast => { return ((ast is StatementAst) && ast.Extent.StartLineNumber == adjustedLineNumber); }, true) as StatementAst;
+                        debugStatement = callingStatement.Find(
+                            ast => ast is StatementAst && ast.Extent.StartLineNumber == adjustedLineNumber, true) as StatementAst;
                     }
                 }
 
diff --git a/src/System.Management.Automation/engine/hostifaces/ConnectionBase.cs b/src/System.Management.Automation/engine/hostifaces/ConnectionBase.cs
index 4b933b590b..25989f6d4c 100644
--- a/src/System.Management.Automation/engine/hostifaces/ConnectionBase.cs
+++ b/src/System.Management.Automation/engine/hostifaces/ConnectionBase.cs
@@ -924,12 +924,13 @@ namespace System.Management.Automation.Runspaces
                         Tuple<WaitHandle[], ManualResetEvent> stateInfo = new Tuple<WaitHandle[], ManualResetEvent>(waitHandles, waitAllIsDone);
 
                         ThreadPool.QueueUserWorkItem(new WaitCallback(
-                                                         delegate (object state)
-                                                         {
-                                                             var tuple = (Tuple<WaitHandle[], ManualResetEvent>)state;
-                                                             WaitHandle.WaitAll(tuple.Item1);
-                                                             tuple.Item2.Set();
-                                                         }), stateInfo);
+                            (object state) =>
+                            {
+                                var tuple = (Tuple<WaitHandle[], ManualResetEvent>)state;
+                                WaitHandle.WaitAll(tuple.Item1);
+                                tuple.Item2.Set();
+                            }),
+                            stateInfo);
                         return waitAllIsDone.WaitOne();
                     }
                 }
diff --git a/src/System.Management.Automation/engine/hostifaces/History.cs b/src/System.Management.Automation/engine/hostifaces/History.cs
index d99e3253b0..499fdbb2ea 100644
--- a/src/System.Management.Automation/engine/hostifaces/History.cs
+++ b/src/System.Management.Automation/engine/hostifaces/History.cs
@@ -1098,12 +1098,12 @@ namespace Microsoft.PowerShell.Commands
             {
                 ps.AddScript(commandToInvoke);
 
-                EventHandler<DataAddedEventArgs> debugAdded = delegate (object sender, DataAddedEventArgs e) { DebugRecord record = (DebugRecord)((PSDataCollection<DebugRecord>)sender)[e.Index]; WriteDebug(record.Message); };
-                EventHandler<DataAddedEventArgs> errorAdded = delegate (object sender, DataAddedEventArgs e) { ErrorRecord record = (ErrorRecord)((PSDataCollection<ErrorRecord>)sender)[e.Index]; WriteError(record); };
-                EventHandler<DataAddedEventArgs> informationAdded = delegate (object sender, DataAddedEventArgs e) { InformationRecord record = (InformationRecord)((PSDataCollection<InformationRecord>)sender)[e.Index]; WriteInformation(record); };
-                EventHandler<DataAddedEventArgs> progressAdded = delegate (object sender, DataAddedEventArgs e) { ProgressRecord record = (ProgressRecord)((PSDataCollection<ProgressRecord>)sender)[e.Index]; WriteProgress(record); };
-                EventHandler<DataAddedEventArgs> verboseAdded = delegate (object sender, DataAddedEventArgs e) { VerboseRecord record = (VerboseRecord)((PSDataCollection<VerboseRecord>)sender)[e.Index]; WriteVerbose(record.Message); };
-                EventHandler<DataAddedEventArgs> warningAdded = delegate (object sender, DataAddedEventArgs e) { WarningRecord record = (WarningRecord)((PSDataCollection<WarningRecord>)sender)[e.Index]; WriteWarning(record.Message); };
+                EventHandler<DataAddedEventArgs> debugAdded = (object sender, DataAddedEventArgs e) => { DebugRecord record = (DebugRecord)((PSDataCollection<DebugRecord>)sender)[e.Index]; WriteDebug(record.Message); };
+                EventHandler<DataAddedEventArgs> errorAdded = (object sender, DataAddedEventArgs e) => { ErrorRecord record = (ErrorRecord)((PSDataCollection<ErrorRecord>)sender)[e.Index]; WriteError(record); };
+                EventHandler<DataAddedEventArgs> informationAdded = (object sender, DataAddedEventArgs e) => { InformationRecord record = (InformationRecord)((PSDataCollection<InformationRecord>)sender)[e.Index]; WriteInformation(record); };
+                EventHandler<DataAddedEventArgs> progressAdded = (object sender, DataAddedEventArgs e) => { ProgressRecord record = (ProgressRecord)((PSDataCollection<ProgressRecord>)sender)[e.Index]; WriteProgress(record); };
+                EventHandler<DataAddedEventArgs> verboseAdded = (object sender, DataAddedEventArgs e) => { VerboseRecord record = (VerboseRecord)((PSDataCollection<VerboseRecord>)sender)[e.Index]; WriteVerbose(record.Message); };
+                EventHandler<DataAddedEventArgs> warningAdded = (object sender, DataAddedEventArgs e) => { WarningRecord record = (WarningRecord)((PSDataCollection<WarningRecord>)sender)[e.Index]; WriteWarning(record.Message); };
 
                 ps.Streams.Debug.DataAdded += debugAdded;
                 ps.Streams.Error.DataAdded += errorAdded;
diff --git a/src/System.Management.Automation/engine/hostifaces/LocalConnection.cs b/src/System.Management.Automation/engine/hostifaces/LocalConnection.cs
index c8a0e9403e..85cb1540c4 100644
--- a/src/System.Management.Automation/engine/hostifaces/LocalConnection.cs
+++ b/src/System.Management.Automation/engine/hostifaces/LocalConnection.cs
@@ -950,10 +950,7 @@ namespace System.Management.Automation.Runspaces
             using (ManualResetEvent remoteRunspaceCloseCompleted = new ManualResetEvent(false))
             {
                 ThrottleManager throttleManager = new ThrottleManager();
-                throttleManager.ThrottleComplete += delegate (object sender, EventArgs e)
-                {
-                    remoteRunspaceCloseCompleted.Set();
-                };
+                throttleManager.ThrottleComplete += (object sender, EventArgs e) => remoteRunspaceCloseCompleted.Set();
 
                 foreach (RemoteRunspace remoteRunspace in runspaces)
                 {
@@ -979,10 +976,7 @@ namespace System.Management.Automation.Runspaces
             using (ManualResetEvent jobsStopCompleted = new ManualResetEvent(false))
             {
                 ThrottleManager throttleManager = new ThrottleManager();
-                throttleManager.ThrottleComplete += delegate (object sender, EventArgs e)
-                {
-                    jobsStopCompleted.Set();
-                };
+                throttleManager.ThrottleComplete += (object sender, EventArgs e) => jobsStopCompleted.Set();
 
                 foreach (Job job in this.JobRepository.Jobs)
                 {
@@ -1016,10 +1010,7 @@ namespace System.Management.Automation.Runspaces
             }
 
             // Disconnect all disconnectable job runspaces found.
-            CloseOrDisconnectAllRemoteRunspaces(() =>
-                {
-                    return disconnectRunspaces;
-                });
+            CloseOrDisconnectAllRemoteRunspaces(() => disconnectRunspaces);
         }
 
         internal void ReleaseDebugger()
diff --git a/src/System.Management.Automation/engine/remoting/client/ClientMethodExecutor.cs b/src/System.Management.Automation/engine/remoting/client/ClientMethodExecutor.cs
index 1fcad961c7..4a25c0679a 100644
--- a/src/System.Management.Automation/engine/remoting/client/ClientMethodExecutor.cs
+++ b/src/System.Management.Automation/engine/remoting/client/ClientMethodExecutor.cs
@@ -156,7 +156,7 @@ namespace System.Management.Automation.Remoting
             // If error-stream is null or we are in pushed-runspace - then write error directly to console.
             if (errorStream == null || IsRunspacePushed(_clientHost))
             {
-                writeErrorAction = delegate (ErrorRecord errorRecord)
+                writeErrorAction = (ErrorRecord errorRecord) =>
                 {
                     try
                     {
@@ -175,10 +175,7 @@ namespace System.Management.Automation.Remoting
             // Otherwise write it to error-stream.
             else
             {
-                writeErrorAction = delegate (ErrorRecord errorRecord)
-                {
-                    errorStream.Write(errorRecord);
-                };
+                writeErrorAction = (ErrorRecord errorRecord) => errorStream.Write(errorRecord);
             }
 
             this.Execute(writeErrorAction);
diff --git a/src/System.Management.Automation/engine/remoting/client/Job.cs b/src/System.Management.Automation/engine/remoting/client/Job.cs
index 982d640176..a616b22a92 100644
--- a/src/System.Management.Automation/engine/remoting/client/Job.cs
+++ b/src/System.Management.Automation/engine/remoting/client/Job.cs
@@ -785,12 +785,12 @@ namespace System.Management.Automation
         {
             this.Error.Add(errorRecord);
             this.InvokeCmdletMethodAndWaitForResults<object>(
-                    delegate (Cmdlet cmdlet)
-                    {
-                        this.WriteError(cmdlet, errorRecord);
-                        return null;
-                    },
-                    out exceptionThrownOnCmdletThread);
+                (Cmdlet cmdlet) =>
+                {
+                    this.WriteError(cmdlet, errorRecord);
+                    return null;
+                },
+                out exceptionThrownOnCmdletThread);
         }
 
         internal virtual void WriteWarning(string message)
@@ -856,15 +856,15 @@ namespace System.Management.Automation
             string caption)
         {
             InvokeCmdletMethodAndIgnoreResults(
-                    delegate (Cmdlet cmdlet)
-                    {
-                        ShouldProcessReason throwAwayProcessReason;
-                        cmdlet.ShouldProcess(
-                            verboseDescription,
-                            verboseWarning,
-                            caption,
-                            out throwAwayProcessReason);
-                    });
+                (Cmdlet cmdlet) =>
+                {
+                    ShouldProcessReason throwAwayProcessReason;
+                    cmdlet.ShouldProcess(
+                        verboseDescription,
+                        verboseWarning,
+                        caption,
+                        out throwAwayProcessReason);
+                });
         }
 
         internal virtual bool ShouldProcess(
@@ -893,7 +893,7 @@ namespace System.Management.Automation
             object resultsLock = new object();
             CmdletMethodInvoker<object> methodInvoker = new CmdletMethodInvoker<object>
             {
-                Action = delegate (Cmdlet cmdlet) { invokeCmdletMethod(cmdlet); return null; },
+                Action = (Cmdlet cmdlet) => { invokeCmdletMethod(cmdlet); return null; },
                 Finished = null,
                 SyncObject = resultsLock
             };
@@ -910,18 +910,18 @@ namespace System.Management.Automation
             using (var gotResultEvent = new ManualResetEventSlim(false))
             {
                 EventHandler<JobStateEventArgs> stateChangedEventHandler =
-                    delegate (object sender, JobStateEventArgs eventArgs)
+                    (object sender, JobStateEventArgs eventArgs) =>
+                    {
+                        if (IsFinishedState(eventArgs.JobStateInfo.State) || eventArgs.JobStateInfo.State == JobState.Stopping)
                         {
-                            if (IsFinishedState(eventArgs.JobStateInfo.State) || eventArgs.JobStateInfo.State == JobState.Stopping)
+                            lock (resultsLock)
                             {
-                                lock (resultsLock)
-                                {
-                                    closureSafeExceptionThrownOnCmdletThread = new OperationCanceledException();
-                                }
-
-                                gotResultEvent.Set();
+                                closureSafeExceptionThrownOnCmdletThread = new OperationCanceledException();
                             }
-                        };
+
+                            gotResultEvent.Set();
+                        }
+                    };
                 this.StateChanged += stateChangedEventHandler;
                 Interlocked.MemoryBarrier();
                 try
@@ -2023,10 +2023,7 @@ namespace System.Management.Automation
                 using (ManualResetEvent connectResult = new ManualResetEvent(false))
                 {
                     EventHandler<EventArgs> throttleCompleteEventHandler =
-                            delegate (object sender, EventArgs eventArgs)
-                            {
-                                connectResult.Set();
-                            };
+                        (object sender, EventArgs eventArgs) => connectResult.Set();
 
                     connectThrottleManager.ThrottleComplete += throttleCompleteEventHandler;
                     try
diff --git a/src/System.Management.Automation/engine/remoting/client/RemotingProtocol2.cs b/src/System.Management.Automation/engine/remoting/client/RemotingProtocol2.cs
index 11ce70dd18..a62eef372f 100644
--- a/src/System.Management.Automation/engine/remoting/client/RemotingProtocol2.cs
+++ b/src/System.Management.Automation/engine/remoting/client/RemotingProtocol2.cs
@@ -1373,7 +1373,7 @@ namespace System.Management.Automation.Internal
             _sessionClosedReason = sessionCloseReason;
 
             // wait for the close to complete and then dispose the transport manager
-            TransportManager.CloseCompleted += delegate (object source, EventArgs args)
+            TransportManager.CloseCompleted += (object source, EventArgs args) =>
             {
                 if (CloseCompleted != null)
                 {
diff --git a/src/System.Management.Automation/engine/remoting/commands/ConnectPSSession.cs b/src/System.Management.Automation/engine/remoting/commands/ConnectPSSession.cs
index c85b88eb26..451c9bea23 100644
--- a/src/System.Management.Automation/engine/remoting/commands/ConnectPSSession.cs
+++ b/src/System.Management.Automation/engine/remoting/commands/ConnectPSSession.cs
@@ -691,10 +691,7 @@ namespace Microsoft.PowerShell.Commands
                     // and this particular method may be called on a thread that
                     // is different from Pipeline Execution Thread. Hence using
                     // a delegate to perform the WriteObject.
-                    Action<Cmdlet> outputWriter = delegate (Cmdlet cmdlet)
-                    {
-                        cmdlet.WriteObject(outSession);
-                    };
+                    Action<Cmdlet> outputWriter = (Cmdlet cmdlet) => cmdlet.WriteObject(outSession);
                     _writeStream.ObjectWriter.Write(outputWriter);
                 }
             }
@@ -728,10 +725,7 @@ namespace Microsoft.PowerShell.Commands
                     }
 
                     ErrorRecord errorRecord = new ErrorRecord(reason, FQEID, ErrorCategory.InvalidOperation, null);
-                    Action<Cmdlet> errorWriter = delegate (Cmdlet cmdlet)
-                    {
-                        cmdlet.WriteError(errorRecord);
-                    };
+                    Action<Cmdlet> errorWriter = (Cmdlet cmdlet) => cmdlet.WriteError(errorRecord);
                     _writeStream.ObjectWriter.Write(errorWriter);
                 }
             }
diff --git a/src/System.Management.Automation/engine/remoting/commands/DisconnectPSSession.cs b/src/System.Management.Automation/engine/remoting/commands/DisconnectPSSession.cs
index 0b9cfeb2d6..96be155d96 100644
--- a/src/System.Management.Automation/engine/remoting/commands/DisconnectPSSession.cs
+++ b/src/System.Management.Automation/engine/remoting/commands/DisconnectPSSession.cs
@@ -481,10 +481,7 @@ namespace Microsoft.PowerShell.Commands
             {
                 if (_writeStream.ObjectWriter.IsOpen)
                 {
-                    Action<Cmdlet> outputWriter = delegate (Cmdlet cmdlet)
-                    {
-                        cmdlet.WriteObject(_remoteSession);
-                    };
+                    Action<Cmdlet> outputWriter = (Cmdlet cmdlet) => cmdlet.WriteObject(_remoteSession);
                     _writeStream.ObjectWriter.Write(outputWriter);
                 }
             }
@@ -506,10 +503,7 @@ namespace Microsoft.PowerShell.Commands
 
                     Exception reason = new RuntimeException(msg, e);
                     ErrorRecord errorRecord = new ErrorRecord(reason, "PSSessionDisconnectFailed", ErrorCategory.InvalidOperation, _remoteSession);
-                    Action<Cmdlet> errorWriter = delegate (Cmdlet cmdlet)
-                    {
-                        cmdlet.WriteError(errorRecord);
-                    };
+                    Action<Cmdlet> errorWriter = (Cmdlet cmdlet) => cmdlet.WriteError(errorRecord);
                     _writeStream.ObjectWriter.Write(errorWriter);
                 }
             }
diff --git a/src/System.Management.Automation/engine/remoting/commands/PushRunspaceCommand.cs b/src/System.Management.Automation/engine/remoting/commands/PushRunspaceCommand.cs
index 2dbf08c34f..29e8560050 100644
--- a/src/System.Management.Automation/engine/remoting/commands/PushRunspaceCommand.cs
+++ b/src/System.Management.Automation/engine/remoting/commands/PushRunspaceCommand.cs
@@ -651,10 +651,7 @@ namespace Microsoft.PowerShell.Commands
         private void HandleURIDirectionReported(object sender, RemoteDataEventArgs<Uri> eventArgs)
         {
             string message = StringUtil.Format(RemotingErrorIdStrings.URIRedirectWarningToHost, eventArgs.Data.OriginalString);
-            Action<Cmdlet> streamObject = delegate (Cmdlet cmdlet)
-            {
-                cmdlet.WriteWarning(message);
-            };
+            Action<Cmdlet> streamObject = (Cmdlet cmdlet) => cmdlet.WriteWarning(message);
             _stream.Write(streamObject);
         }
 
@@ -794,10 +791,7 @@ namespace Microsoft.PowerShell.Commands
         /// </summary>
         private RemoteRunspace GetRunspaceMatchingRunspaceId(Guid remoteRunspaceId)
         {
-            Predicate<PSSession> condition = delegate (PSSession info)
-            {
-                return info.InstanceId == remoteRunspaceId;
-            };
+            Predicate<PSSession> condition = (PSSession info) => info.InstanceId == remoteRunspaceId;
             PSRemotingErrorId tooFew = PSRemotingErrorId.RemoteRunspaceNotAvailableForSpecifiedRunspaceId;
             PSRemotingErrorId tooMany = PSRemotingErrorId.RemoteRunspaceHasMultipleMatchesForSpecifiedRunspaceId;
             string tooFewResourceString = RemotingErrorIdStrings.RemoteRunspaceNotAvailableForSpecifiedRunspaceId;
@@ -810,10 +804,7 @@ namespace Microsoft.PowerShell.Commands
         /// </summary>
         private RemoteRunspace GetRunspaceMatchingSessionId(int sessionId)
         {
-            Predicate<PSSession> condition = delegate (PSSession info)
-            {
-                return info.Id == sessionId;
-            };
+            Predicate<PSSession> condition = (PSSession info) => info.Id == sessionId;
             PSRemotingErrorId tooFew = PSRemotingErrorId.RemoteRunspaceNotAvailableForSpecifiedSessionId;
             PSRemotingErrorId tooMany = PSRemotingErrorId.RemoteRunspaceHasMultipleMatchesForSpecifiedSessionId;
             string tooFewResourceString = RemotingErrorIdStrings.RemoteRunspaceNotAvailableForSpecifiedSessionId;
@@ -826,7 +817,7 @@ namespace Microsoft.PowerShell.Commands
         /// </summary>
         private RemoteRunspace GetRunspaceMatchingName(string name)
         {
-            Predicate<PSSession> condition = delegate (PSSession info)
+            Predicate<PSSession> condition = (PSSession info) =>
             {
                 // doing case-insensitive match for session name
                 return info.Name.Equals(name, StringComparison.OrdinalIgnoreCase);
diff --git a/src/System.Management.Automation/engine/remoting/commands/newrunspacecommand.cs b/src/System.Management.Automation/engine/remoting/commands/newrunspacecommand.cs
index 5645272bbe..c64959a4aa 100644
--- a/src/System.Management.Automation/engine/remoting/commands/newrunspacecommand.cs
+++ b/src/System.Management.Automation/engine/remoting/commands/newrunspacecommand.cs
@@ -397,10 +397,7 @@ namespace Microsoft.PowerShell.Commands
         private void HandleURIDirectionReported(object sender, RemoteDataEventArgs<Uri> eventArgs)
         {
             string message = StringUtil.Format(RemotingErrorIdStrings.URIRedirectWarningToHost, eventArgs.Data.OriginalString);
-            Action<Cmdlet> warningWriter = delegate (Cmdlet cmdlet)
-            {
-                cmdlet.WriteWarning(message);
-            };
+            Action<Cmdlet> warningWriter = (Cmdlet cmdlet) => cmdlet.WriteWarning(message);
             _stream.Write(warningWriter);
         }
 
@@ -450,10 +447,7 @@ namespace Microsoft.PowerShell.Commands
 
                         this.RunspaceRepository.Add(remoteRunspaceInfo);
 
-                        Action<Cmdlet> outputWriter = delegate (Cmdlet cmdlet)
-                        {
-                            cmdlet.WriteObject(remoteRunspaceInfo);
-                        };
+                        Action<Cmdlet> outputWriter = (Cmdlet cmdlet) => cmdlet.WriteObject(remoteRunspaceInfo);
                         if (writer.IsOpen)
                         {
                             writer.Write(outputWriter);
@@ -546,7 +540,7 @@ namespace Microsoft.PowerShell.Commands
                                    ErrorCategory.OpenError, null, null,
                                         null, null, null, errorDetails, null);
 
-                        Action<Cmdlet> errorWriter = delegate (Cmdlet cmdlet)
+                        Action<Cmdlet> errorWriter = (Cmdlet cmdlet) =>
                         {
                             //
                             // In case of PSDirectException, we should output the precise error message
@@ -589,10 +583,7 @@ namespace Microsoft.PowerShell.Commands
                                         (connectionUri != null) ?
                                         connectionUri.AbsoluteUri : string.Empty);
 
-                        Action<Cmdlet> verboseWriter = delegate (Cmdlet cmdlet)
-                        {
-                            cmdlet.WriteVerbose(message);
-                        };
+                        Action<Cmdlet> verboseWriter = (Cmdlet cmdlet) => cmdlet.WriteVerbose(message);
                         if (writer.IsOpen)
                         {
                             writer.Write(verboseWriter);
@@ -607,10 +598,7 @@ namespace Microsoft.PowerShell.Commands
                                  "PSSessionStateClosed",
                                        ErrorCategory.OpenError, remoteRunspace);
 
-                            Action<Cmdlet> errorWriter = delegate (Cmdlet cmdlet)
-                            {
-                                cmdlet.WriteError(errorRecord);
-                            };
+                            Action<Cmdlet> errorWriter = (Cmdlet cmdlet) => cmdlet.WriteError(errorRecord);
                             if (writer.IsOpen)
                             {
                                 writer.Write(errorWriter);
@@ -716,10 +704,7 @@ namespace Microsoft.PowerShell.Commands
                         ErrorRecord errorRecord = new ErrorRecord(e, "CreateRemoteRunspaceFailed",
                                 ErrorCategory.InvalidArgument, remoteRunspaceInfo);
 
-                        Action<Cmdlet> errorWriter = delegate (Cmdlet cmdlet)
-                        {
-                            cmdlet.WriteError(errorRecord);
-                        };
+                        Action<Cmdlet> errorWriter = (Cmdlet cmdlet) => cmdlet.WriteError(errorRecord);
                         writer.Write(errorWriter);
                     }
                 }
@@ -853,10 +838,7 @@ namespace Microsoft.PowerShell.Commands
                     ErrorRecord errorRecord = new ErrorRecord(e, "CreateRemoteRunspaceFailed",
                             ErrorCategory.InvalidArgument, resolvedComputerNames[i]);
 
-                    Action<Cmdlet> errorWriter = delegate (Cmdlet cmdlet)
-                    {
-                        cmdlet.WriteError(errorRecord);
-                    };
+                    Action<Cmdlet> errorWriter = (Cmdlet cmdlet) => cmdlet.WriteError(errorRecord);
                     writer.Write(errorWriter);
                 }
             }
@@ -1262,10 +1244,7 @@ namespace Microsoft.PowerShell.Commands
             ErrorRecord errorRecord = new ErrorRecord(e, "CreateRemoteRunspaceFailed",
                 ErrorCategory.InvalidArgument, uri);
 
-            Action<Cmdlet> errorWriter = delegate (Cmdlet cmdlet)
-            {
-                cmdlet.WriteError(errorRecord);
-            };
+            Action<Cmdlet> errorWriter = (Cmdlet cmdlet) => cmdlet.WriteError(errorRecord);
             writer.Write(errorWriter);
         }
 
diff --git a/src/System.Management.Automation/engine/remoting/common/RemoteSessionNamedPipe.cs b/src/System.Management.Automation/engine/remoting/common/RemoteSessionNamedPipe.cs
index 49dbe5b855..af96c2c083 100644
--- a/src/System.Management.Automation/engine/remoting/common/RemoteSessionNamedPipe.cs
+++ b/src/System.Management.Automation/engine/remoting/common/RemoteSessionNamedPipe.cs
@@ -900,10 +900,7 @@ namespace System.Management.Automation.Remoting
 
             ManualResetEventSlim clientConnectionEnded = new ManualResetEventSlim(false);
             IPCNamedPipeServer.ListenerEnded -= OnIPCNamedPipeServerEnded;
-            IPCNamedPipeServer.ListenerEnded += (sender, e) =>
-                {
-                    clientConnectionEnded.Set();
-                };
+            IPCNamedPipeServer.ListenerEnded += (sender, e) => clientConnectionEnded.Set();
 
             // Wait for server to service a single client connection.
             clientConnectionEnded.Wait();
diff --git a/src/System.Management.Automation/engine/remoting/fanin/BaseTransportManager.cs b/src/System.Management.Automation/engine/remoting/fanin/BaseTransportManager.cs
index 269b404a0a..552dadb11b 100644
--- a/src/System.Management.Automation/engine/remoting/fanin/BaseTransportManager.cs
+++ b/src/System.Management.Automation/engine/remoting/fanin/BaseTransportManager.cs
@@ -983,10 +983,7 @@ namespace System.Management.Automation.Remoting.Client
             else
             {
                 // wait for the close to be completed and then release the resources.
-                this.CloseCompleted += delegate (object source, EventArgs args)
-                {
-                    Dispose(false);
-                };
+                this.CloseCompleted += (object source, EventArgs args) => Dispose(false);
 
                 try
                 {
@@ -1391,7 +1388,7 @@ namespace System.Management.Automation.Remoting.Server
             // Use thread-pool thread to raise the error handler..see explanation
             // in the method summary
             ThreadPool.QueueUserWorkItem(new WaitCallback(
-                delegate (object state)
+                (object state) =>
                 {
                     TransportErrorOccuredEventArgs eventArgs = new TransportErrorOccuredEventArgs(e,
                         TransportMethodEnum.Unknown);
diff --git a/src/System.Management.Automation/engine/remoting/fanin/WSManTransportManager.cs b/src/System.Management.Automation/engine/remoting/fanin/WSManTransportManager.cs
index 813d5d5b37..fac7efbefa 100644
--- a/src/System.Management.Automation/engine/remoting/fanin/WSManTransportManager.cs
+++ b/src/System.Management.Automation/engine/remoting/fanin/WSManTransportManager.cs
@@ -2576,7 +2576,7 @@ namespace System.Management.Automation.Remoting.Client
             ThreadPool.QueueUserWorkItem(new WaitCallback(
                 // wsManSessionHandle is passed as parameter to allow the thread to be independent
                 // of the rest of the parent object.
-                delegate (object state)
+                (object state) =>
                 {
                     IntPtr sessionHandle = (IntPtr)state;
                     if (sessionHandle != IntPtr.Zero)
@@ -2626,11 +2626,7 @@ namespace System.Management.Automation.Remoting.Client
             // Dispose and de-initialize the WSManAPIData instance object on separate worker thread to ensure
             // it is not run on a WinRM thread (which will fail).
             // Note that WSManAPIData.Dispose() method is thread safe.
-            System.Threading.ThreadPool.QueueUserWorkItem(
-                (state) =>
-                {
-                    tempWSManApiData.Dispose();
-                });
+            ThreadPool.QueueUserWorkItem((_) => tempWSManApiData.Dispose());
         }
 
         #endregion
diff --git a/src/System.Management.Automation/engine/remoting/server/serverremotesession.cs b/src/System.Management.Automation/engine/remoting/server/serverremotesession.cs
index 16978ff04e..fa3c4501d4 100644
--- a/src/System.Management.Automation/engine/remoting/server/serverremotesession.cs
+++ b/src/System.Management.Automation/engine/remoting/server/serverremotesession.cs
@@ -712,7 +712,7 @@ namespace System.Management.Automation.Remoting
             // enqueue a connect event in state machine to let session do any other post-connect operation
             // Do this outside of the synchronous connect operation, as otherwise connect can easily get deadlocked
             ThreadPool.QueueUserWorkItem(new WaitCallback(
-                delegate (object state)
+                (object state) =>
                 {
                     RemoteSessionStateMachineEventArgs startEventArg = new RemoteSessionStateMachineEventArgs(RemoteSessionEvent.ConnectSession);
                     SessionDataStructureHandler.StateMachine.RaiseEvent(startEventArg);
diff --git a/src/System.Management.Automation/engine/runtime/CompiledScriptBlock.cs b/src/System.Management.Automation/engine/runtime/CompiledScriptBlock.cs
index b118833c43..a706315f52 100644
--- a/src/System.Management.Automation/engine/runtime/CompiledScriptBlock.cs
+++ b/src/System.Management.Automation/engine/runtime/CompiledScriptBlock.cs
@@ -723,7 +723,7 @@ namespace System.Management.Automation
         internal SteppablePipeline GetSteppablePipelineImpl(CommandOrigin commandOrigin, object[] args)
         {
             var pipelineAst = GetSimplePipeline(
-                resourceString => { throw PSTraceSource.NewInvalidOperationException(resourceString); });
+                resourceString => throw PSTraceSource.NewInvalidOperationException(resourceString));
             Diagnostics.Assert(pipelineAst != null, "This should be checked by GetSimplePipeline");
 
             if (pipelineAst.PipelineElements[0] is not CommandAst)
diff --git a/src/System.Management.Automation/namespaces/FileSystemContentStream.cs b/src/System.Management.Automation/namespaces/FileSystemContentStream.cs
index 8492136196..5134997070 100644
--- a/src/System.Management.Automation/namespaces/FileSystemContentStream.cs
+++ b/src/System.Management.Automation/namespaces/FileSystemContentStream.cs
@@ -903,8 +903,8 @@ namespace Microsoft.PowerShell.Commands
             {
                 ErrorEventArgs errorEventArgs = null;
                 var tcs = new TaskCompletionSource<FileSystemEventArgs>();
-                FileSystemEventHandler onChangedHandler = (object source, FileSystemEventArgs e) => { tcs.TrySetResult(e); };
-                RenamedEventHandler onRenamedHandler = (object source, RenamedEventArgs e) => { tcs.TrySetResult(e); };
+                FileSystemEventHandler onChangedHandler = (object source, FileSystemEventArgs e) => tcs.TrySetResult(e);
+                RenamedEventHandler onRenamedHandler = (object source, RenamedEventArgs e) => tcs.TrySetResult(e);
                 ErrorEventHandler onErrorHandler = (object source, ErrorEventArgs e) =>
                 {
                     errorEventArgs = e;
diff --git a/src/System.Management.Automation/namespaces/SessionStateProviderBase.cs b/src/System.Management.Automation/namespaces/SessionStateProviderBase.cs
index b0386cedfa..e6050a44d5 100644
--- a/src/System.Management.Automation/namespaces/SessionStateProviderBase.cs
+++ b/src/System.Management.Automation/namespaces/SessionStateProviderBase.cs
@@ -326,7 +326,7 @@ namespace Microsoft.PowerShell.Commands
                 }
 
                 sortedEntries.Sort(
-                    delegate (DictionaryEntry left, DictionaryEntry right)
+                    (DictionaryEntry left, DictionaryEntry right) =>
                     {
                         string leftKey = (string)left.Key;
                         string rightKey = (string)right.Key;