avoid duplicate dictionary lookups

src/Cake.Cli/Hosts/DescriptionScriptHost.cs

@@ -67,9 +67,9 @@ private void PrintTaskDescriptions()
             _console.WriteLine();
             _console.WriteLine(lineFormat, "Task", "Description");
             _console.WriteLine(new String('=', maxTaskNameLength + 50));
-            foreach (var key in _descriptions.Keys)
+            foreach (var (key, value) in _descriptions)
             {
-                _console.WriteLine(lineFormat, key, _descriptions[key]);
+                _console.WriteLine(lineFormat, key, value);
             }
         }
      }

src/Cake.Common/Build/TeamCity/Data/TeamCityBuildInfo.cs

@@ -87,8 +87,8 @@ public string VcsBranchName
         {
             get
             {
-                var rootBranchKey = ConfigProperties.Keys.FirstOrDefault(k => k.StartsWith("teamcity.build.vcs.branch."));
-                return !string.IsNullOrWhiteSpace(rootBranchKey) ? ConfigProperties[rootBranchKey] : string.Empty;
+                var (key, value) = ConfigProperties.FirstOrDefault(_ => _.Key.StartsWith("teamcity.build.vcs.branch."));
+                return !string.IsNullOrWhiteSpace(key) ? value : string.Empty;
             }
         }
 

src/Cake.Common/Tools/Chocolatey/Pack/ChocolateyNuSpecTransformer.cs

@@ -55,9 +55,9 @@ public static void Transform(XmlDocument document, ChocolateyPackSettings settin
             var namespaceManager = new XmlNamespaceManager(document.NameTable);
             namespaceManager.AddNamespace("nu", ChocolateyNuSpecXsd);
 
-            foreach (var elementName in _mappings.Keys)
+            foreach (var (elementName, element) in _mappings)
             {
-                var content = _mappings[elementName](settings);
+                var content = element(settings);
                 if (content != null)
                 {
                     // Replace the node content.

src/Cake.Common/Tools/XBuild/XBuildRunner.cs

@@ -107,11 +107,11 @@ private static string GetVerbosityName(Verbosity verbosity)
 
         private static IEnumerable<string> GetPropertyArguments(IDictionary<string, IList<string>> properties)
         {
-            foreach (var propertyKey in properties.Keys)
+            foreach (var (key, values) in properties)
             {
-                foreach (var propertyValue in properties[propertyKey])
+                foreach (var propertyValue in values)
                 {
-                    yield return string.Concat("/p:", propertyKey.Quote(), "=", propertyValue.Quote());
+                    yield return string.Concat("/p:", key.Quote(), "=", propertyValue.Quote());
                 }
             }
         }

src/Cake.Core/CakeEnvironmentExtensions.cs

@@ -32,9 +32,9 @@ public static string ExpandEnvironmentVariables(this ICakeEnvironment environmen
             foreach (Match match in matches)
             {
                 string value = match.Groups[1].Value;
-                if (variables.ContainsKey(value))
+                if (variables.TryGetValue(value, out var variable))
                 {
-                    text = text.Replace(match.Value, variables[value]);
+                    text = text.Replace(match.Value, variable);
                 }
             }
 

src/Cake.Core/Configuration/CakeConfiguration.cs

@@ -27,8 +27,7 @@ public CakeConfiguration(IDictionary<string, string> lookup)
         public string GetValue(string key)
         {
             key = KeyNormalizer.Normalize(key);
-            return _lookup.ContainsKey(key)
-                ? _lookup[key] : null;
+            return _lookup.GetValueOrDefault(key);
         }
     }
 }

src/Cake.Core/Configuration/CakeConfigurationProvider.cs

@@ -95,16 +95,16 @@ public ICakeConfiguration CreateConfiguration(DirectoryPath path, IEnumerable<Ke
             {
                 var parser = new ConfigurationParser(_fileSystem, _environment);
                 var configuration = parser.Read(configurationPath);
-                foreach (var key in configuration.Keys)
+                foreach (var (key, value) in configuration)
                 {
-                    result[KeyNormalizer.Normalize(key)] = configuration[key];
+                    result[KeyNormalizer.Normalize(key)] = value;
                 }
             }
 
             // Add all arguments.
-            foreach (var key in arguments.Keys)
+            foreach (var (key, value) in arguments)
             {
-                result[KeyNormalizer.Normalize(key)] = arguments[key];
+                result[KeyNormalizer.Normalize(key)] = value;
             }
 
             return new CakeConfiguration(result);

src/Cake.Core/Tooling/ToolRepository.cs

@@ -55,9 +55,9 @@ public void Register(FilePath path)
         /// <inheritdoc/>
         public IEnumerable<FilePath> Resolve(string tool)
         {
-            if (_paths.ContainsKey(tool))
+            if (_paths.TryGetValue(tool, out var paths))
             {
-                return _paths[tool];
+                return paths;
             }
 
             return Enumerable.Empty<FilePath>();

src/Cake.DotNetTool.Module/DotNetToolContentResolver.cs

@@ -115,19 +115,19 @@ private IEnumerable<IFile> GetFiles(DirectoryPath path, PackageReference package
             }
 
             // Include files.
-            if (package.Parameters.ContainsKey("include"))
+            if (package.Parameters.TryGetValue("include", out var includes))
             {
-                foreach (var include in package.Parameters["include"])
+                foreach (var include in includes)
                 {
                     var includePath = string.Concat(path.FullPath, "/", include.TrimStart('/'));
                     collection.Add(_globber.GetFiles(includePath));
                 }
             }
 
             // Exclude files.
-            if (package.Parameters.ContainsKey("exclude"))
+            if (package.Parameters.TryGetValue("exclude", out var excludes))
             {
-                foreach (var exclude in package.Parameters["exclude"])
+                foreach (var exclude in excludes)
                 {
                     var excludePath = string.Concat(path.FullPath, "/", exclude.TrimStart('/'));
                     collection.Remove(_globber.GetFiles(excludePath));

src/Cake.DotNetTool.Module/DotNetToolPackageInstaller.cs

@@ -124,9 +124,9 @@ public IReadOnlyCollection<IFile> Install(PackageReference package, PackageType
                 // what is already installed
                 string requestedVersion = null;
 
-                if (package.Parameters.ContainsKey("version"))
+                if (package.Parameters.TryGetValue("version", out var version))
                 {
-                    requestedVersion = package.Parameters["version"].First();
+                    requestedVersion = version.First();
                 }
 
                 if (requestedVersion == null)
@@ -272,17 +272,17 @@ private static ProcessArgumentBuilder GetArguments(
                 }
 
                 // Version
-                if (definition.Parameters.ContainsKey("version"))
+                if (definition.Parameters.TryGetValue("version", out var version))
                 {
                     arguments.Append("--version");
-                    arguments.Append(definition.Parameters["version"].First());
+                    arguments.Append(version.First());
                 }
 
                 // Config File
-                if (definition.Parameters.ContainsKey("configfile"))
+                if (definition.Parameters.TryGetValue("configfile", out var config))
                 {
                     arguments.Append("--configfile");
-                    arguments.AppendQuoted(definition.Parameters["configfile"].First());
+                    arguments.AppendQuoted(config.First());
                 }
 
                 // Whether to ignore failed sources
@@ -292,10 +292,10 @@ private static ProcessArgumentBuilder GetArguments(
                 }
 
                 // Framework
-                if (definition.Parameters.ContainsKey("framework"))
+                if (definition.Parameters.TryGetValue("framework", out var framework))
                 {
                     arguments.Append("--framework");
-                    arguments.Append(definition.Parameters["framework"].First());
+                    arguments.Append(framework.First());
                 }
 
                 switch (log.Verbosity)

src/Cake.NuGet/Client/PackageReferenceExtensions.cs

@@ -15,9 +15,9 @@ internal static class PackageReferenceExtensions
         public static bool ShouldLoadDependencies(this PackageReference packageReference, ICakeConfiguration config)
         {
             bool loadDependencies;
-            if (packageReference.Parameters.ContainsKey(LoadDependenciesKey))
+            if (packageReference.Parameters.TryGetValue(LoadDependenciesKey, out var parameter))
             {
-                bool.TryParse(packageReference.Parameters[LoadDependenciesKey].FirstOrDefault() ?? bool.TrueString, out loadDependencies);
+                bool.TryParse(parameter.FirstOrDefault() ?? bool.TrueString, out loadDependencies);
             }
             else
             {
@@ -29,9 +29,9 @@ public static bool ShouldLoadDependencies(this PackageReference packageReference
         public static bool IsPrerelease(this PackageReference packageReference)
         {
             var isPreRelease = false;
-            if (packageReference.Parameters.ContainsKey("prerelease"))
+            if (packageReference.Parameters.TryGetValue("prerelease", out var prerelease))
             {
-                bool.TryParse(packageReference.Parameters["prerelease"].FirstOrDefault() ?? bool.TrueString, out isPreRelease);
+                bool.TryParse(prerelease.FirstOrDefault() ?? bool.TrueString, out isPreRelease);
             }
             return isPreRelease;
         }

src/Cake.NuGet/Installers/InProcessInstaller.cs

@@ -252,9 +252,9 @@ private static NuGetVersion GetNuGetVersion(PackageReference package, IEnumerabl
         {
             NuGetVersion version = null;
             VersionRange versionRange = null;
-            if (package.Parameters.ContainsKey("version"))
+            if (package.Parameters.TryGetValue("version", out var versions))
             {
-                var versionString = package.Parameters["version"].First();
+                var versionString = versions.First();
                 if (NuGetVersion.TryParse(versionString, out version))
                 {
                     return version;

src/Cake.NuGet/Installers/OutOfProcessInstaller.cs

@@ -133,9 +133,9 @@ private static DirectoryPath GetPackagePath(IDirectory root, string package)
 
         private static DirectoryPath GetPackagePath(DirectoryPath root, PackageReference package)
         {
-            if (package.Parameters.ContainsKey("version"))
+            if (package.Parameters.TryGetValue("version", out var versions))
             {
-                var version = package.Parameters["version"].First();
+                var version = versions.First();
                 return root.Combine($"{package.Package}.{version}".ToLowerInvariant());
             }
             return root.Combine(package.Package.ToLowerInvariant());
@@ -215,10 +215,10 @@ private static ProcessArgumentBuilder GetArguments(
             }
 
             // Version
-            if (definition.Parameters.ContainsKey("version"))
+            if (definition.Parameters.TryGetValue("version", out var version))
             {
                 arguments.Append("-Version");
-                arguments.AppendQuoted(definition.Parameters["version"].First());
+                arguments.AppendQuoted(version.First());
             }
 
             // Prerelease

src/Cake.NuGet/NuGetContentResolver.cs

@@ -136,19 +136,19 @@ private IEnumerable<IFile> GetFiles(DirectoryPath path, PackageReference package
             }
 
             // Include files.
-            if (package.Parameters.ContainsKey("include"))
+            if (package.Parameters.TryGetValue("include", out var includes))
             {
-                foreach (var include in package.Parameters["include"])
+                foreach (var include in includes)
                 {
                     var includePath = string.Concat(path.FullPath, "/", include.TrimStart('/'));
                     collection.Add(_globber.GetFiles(includePath));
                 }
             }
 
             // Exclude files.
-            if (package.Parameters.ContainsKey("exclude"))
+            if (package.Parameters.TryGetValue("exclude", out var excludes))
             {
-                foreach (var exclude in package.Parameters["exclude"])
+                foreach (var exclude in excludes)
                 {
                     var excludePath = string.Concat(path.FullPath, "/", exclude.TrimStart('/'));
                     collection.Remove(_globber.GetFiles(excludePath));

src/Cake.Testing/FakeEnvironment.cs

@@ -92,9 +92,9 @@ public static FakeEnvironment CreateWindowsEnvironment(bool is64Bit = true)
         /// <inheritdoc/>
         public DirectoryPath GetSpecialPath(SpecialPath path)
         {
-            if (_specialPaths.ContainsKey(path))
+            if (_specialPaths.TryGetValue(path, out var specialPath))
             {
-                return _specialPaths[path];
+                return specialPath;
             }
             const string format = "The special path '{0}' is not supported.";
             throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, format, path));

src/Cake.Testing/FakeFileSystemTree.cs

@@ -60,7 +60,7 @@ public FakeDirectory CreateDirectory(FakeDirectory directory)
                 // Calculate the current path.
                 path = parent != null ? parent.Path.Combine(currentSegment) : new DirectoryPath(currentSegment);
 
-                if (!children.Directories.ContainsKey(path))
+                if (!children.Directories.TryGetValue(path, out var childDirectory))
                 {
                     current = queue.Count == 0 ? directory : new FakeDirectory(this, path);
                     current.Parent = parent ?? _root;
@@ -69,7 +69,7 @@ public FakeDirectory CreateDirectory(FakeDirectory directory)
                 }
                 else
                 {
-                    current = children.Directories[path];
+                    current = childDirectory;
                 }
 
                 current.Exists = true;
@@ -196,12 +196,12 @@ public FakeDirectory FindDirectory(DirectoryPath path)
                 path = parent != null ? parent.Path.Combine(segment) : new DirectoryPath(segment);
 
                 // Find the current path.
-                if (!children.Directories.ContainsKey(path))
+                if (!children.Directories.TryGetValue(path, out var directory))
                 {
                     return null;
                 }
 
-                current = children.Directories[path];
+                current = directory;
                 children = current.Content;
             }
 
@@ -213,9 +213,9 @@ public FakeFile FindFile(FilePath path)
             var directory = FindDirectory(path.GetDirectory());
             if (directory != null)
             {
-                if (directory.Content.Files.ContainsKey(path))
+                if (directory.Content.Files.TryGetValue(path, out var file))
                 {
-                    return directory.Content.Files[path];
+                    return file;
                 }
             }
             return null;