lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [lucenenet] 06/06: SWEEP: Eliminated several unnecessary lookups by converting ContainsKey to TryGetValue
Date Wed, 08 Jan 2020 08:35:15 GMT
This is an automated email from the ASF dual-hosted git repository.

nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git

commit 01d65bb1409cb34a8bc1444b67dd1ab011d6d4fa
Author: Shad Storhaug <shad@shadstorhaug.com>
AuthorDate: Tue Jan 7 23:18:18 2020 +0700

    SWEEP: Eliminated several unnecessary lookups by converting ContainsKey to TryGetValue
---
 Directory.Build.targets                            |  2 ++
 .../Analysis/CharFilter/MappingCharFilter.cs       |  3 +-
 .../Compound/Hyphenation/HyphenationTree.cs        |  4 +--
 .../Analysis/Compound/Hyphenation/PatternParser.cs |  3 +-
 .../Analysis/Hunspell/Dictionary.cs                | 12 +++----
 .../Analysis/Nl/DutchStemmer.cs                    | 11 ++----
 .../Pattern/PatternCaptureGroupFilterFactory.cs    |  2 +-
 .../Analysis/Query/QueryAutoStopWordAnalyzer.cs    |  3 +-
 .../Analysis/Synonym/SynonymFilterFactory.cs       |  2 +-
 .../Analysis/Synonym/SynonymMap.cs                 |  3 +-
 .../Analysis/Util/CharArrayMap.cs                  |  4 +--
 .../Analysis/Util/CharacterUtils.cs                |  6 ++--
 .../Language/DaitchMokotoffSoundex.cs              |  4 +--
 src/Lucene.Net.Analysis.SmartCn/Hhmm/BiSegGraph.cs |  5 +--
 .../Egothor.Stemmer/Optimizer.cs                   |  5 ++-
 .../Egothor.Stemmer/Row.cs                         |  3 +-
 src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs |  8 +----
 .../Support/Sax/Helpers/NamespaceSupport.cs        |  4 +--
 .../KNearestNeighborClassifier.cs                  |  4 +--
 .../JS/JavascriptCompiler.cs                       | 11 ++----
 src/Lucene.Net.Facet/FacetsConfig.cs               | 40 +++++++++------------
 .../Taxonomy/Directory/DirectoryTaxonomyWriter.cs  |  4 +--
 .../AbstractSecondPassGroupingCollector.cs         |  2 +-
 src/Lucene.Net.Grouping/SearchGroup.cs             |  3 +-
 .../Classic/QueryParserBase.cs                     |  4 +--
 src/Lucene.Net.QueryParser/Ext/Extensions.cs       |  9 ++---
 .../Flexible/Core/Nodes/QueryNodeImpl.cs           |  2 ++
 .../Surround/Query/SpanNearClauseFactory.cs        |  4 +--
 .../Analysis/BaseTokenStreamTestCase.cs            |  8 ++---
 .../Analysis/ValidatingTokenFilter.cs              |  6 ++--
 .../Index/BaseIndexFileFormatTestCase.cs           |  2 +-
 .../Index/BaseTermVectorsFormatTestCase.cs         | 27 +++++++++-----
 src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs | 10 +++---
 .../Analysis/Core/TestRandomChains.cs              |  6 ++--
 .../Analysis/Synonym/TestSynonymMapFilter.cs       |  3 +-
 .../Taxonomy/TestTaxonomyFacetCounts.cs            |  3 +-
 .../Taxonomy/TestTaxonomyFacetSumValueSource.cs    |  3 +-
 .../AllGroupHeadsCollectorTest.cs                  |  4 +--
 .../GroupFacetCollectorTest.cs                     | 23 +++++-------
 src/Lucene.Net.Tests.Grouping/TestGrouping.cs      |  6 ++--
 .../VectorHighlight/SimpleFragmentsBuilderTest.cs  |  6 ++--
 src/Lucene.Net.Tests.Join/TestJoinUtil.cs          | 42 ++++++++++------------
 .../Document/TestLazyDocument.cs                   |  4 +--
 .../Suggest/Analyzing/AnalyzingSuggesterTest.cs    |  4 +--
 .../Suggest/Analyzing/TestFreeTextSuggester.cs     | 11 +++---
 .../Suggest/DocumentDictionaryTest.cs              |  8 ++---
 .../Suggest/DocumentValueSourceDictionaryTest.cs   | 10 +++---
 src/Lucene.Net.Tests/Index/TestMultiFields.cs      |  6 ++--
 src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs  | 11 +++---
 .../Search/TestCustomSearcherSort.cs               |  4 +--
 .../Codecs/PerField/PerFieldDocValuesFormat.cs     |  7 ++--
 .../Codecs/PerField/PerFieldPostingsFormat.cs      |  7 ++--
 src/Lucene.Net/Index/IndexFileDeleter.cs           | 23 +++++-------
 src/Lucene.Net/Index/IndexWriter.cs                |  8 ++---
 src/Lucene.Net/Util/FieldCacheSanityChecker.cs     |  5 +--
 src/Lucene.Net/Util/MapOfSets.cs                   | 22 ++++--------
 56 files changed, 190 insertions(+), 256 deletions(-)

diff --git a/Directory.Build.targets b/Directory.Build.targets
index a1f7171..774ba44 100644
--- a/Directory.Build.targets
+++ b/Directory.Build.targets
@@ -30,6 +30,8 @@
     <DefineConstants>$(DefineConstants);FEATURE_CONDITIONALWEAKTABLE_ENUMERATOR</DefineConstants>
     <DefineConstants>$(DefineConstants);FEATURE_CONDITIONALWEAKTABLE_ADDORUPDATE</DefineConstants>
 
+    <DefineConstants>$(DefineConstants);FEATURE_HASHSET_CAPACITY</DefineConstants>
+    
   </PropertyGroup>
 
   <!-- Features in .NET Framework 4.5+, .NET Standard 2.x, .NET Core 2.x, and .NET Core 3.x -->
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/MappingCharFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/MappingCharFilter.cs
index de79d64..484891d 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/MappingCharFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/MappingCharFilter.cs
@@ -130,8 +130,7 @@ namespace Lucene.Net.Analysis.CharFilters
                 {
                     // LUCENENET fix: Check the dictionary to ensure it contains a key before reading it.
                     char key = Convert.ToChar((char)firstCH);
-                    FST.Arc<CharsRef> arc = cachedRootArcs.ContainsKey(key) ? cachedRootArcs[key] : null;
-                    if (arc != null)
+                    if (cachedRootArcs.TryGetValue(key, out FST.Arc<CharsRef> arc) && arc != null)
                     {
                         if (!FST.TargetHasArcs(arc))
                         {
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/HyphenationTree.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/HyphenationTree.cs
index 2342d2c..3d43e34 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/HyphenationTree.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/HyphenationTree.cs
@@ -469,11 +469,11 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
 
             // check exception list first
             string sw = new string(word, 1, len);
-            if (m_stoplist.ContainsKey(sw))
+            // LUCENENET: Eliminated extra lookup by using TryGetValue instead of ContainsKey
+            if (m_stoplist.TryGetValue(sw, out IList<object> hw))
             {
                 // assume only simple hyphens (Hyphen.pre="-", Hyphen.post = Hyphen.no =
                 // null)
-                IList<object> hw = m_stoplist[sw];
                 int j = 0;
                 for (i = 0; i < hw.Count; i++)
                 {
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/PatternParser.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/PatternParser.cs
index f73d675..b49e37d 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/PatternParser.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/PatternParser.cs
@@ -432,8 +432,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         {
             if (local.Equals("hyphen-char", StringComparison.Ordinal))
             {
-                string h = attrs.ContainsKey("value") ? attrs["value"] : null;
-                if (h != null && h.Length == 1)
+                if (attrs.TryGetValue("value", out string h) && h != null && h.Length == 1)
                 {
                     hyphenChar = h[0];
                 }
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs
index 27bf50d..49b04c2 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs
@@ -480,8 +480,7 @@ namespace Lucene.Net.Analysis.Hunspell
                 }
 
                 // deduplicate patterns
-                int? patternIndex = seenPatterns.ContainsKey(regex) ? seenPatterns[regex] : null;
-                if (patternIndex == null)
+                if (!seenPatterns.TryGetValue(regex, out int? patternIndex) || patternIndex == null)
                 {
                     patternIndex = patterns.Count;
                     if (patternIndex > short.MaxValue)
@@ -493,8 +492,7 @@ namespace Lucene.Net.Analysis.Hunspell
                     patterns.Add(pattern);
                 }
 
-                int? stripOrd = seenStrips.ContainsKey(strip) ? seenStrips[strip] : null;
-                if (stripOrd == null)
+                if (!seenStrips.TryGetValue(strip, out int? stripOrd) || stripOrd == null)
                 {
                     stripOrd = seenStrips.Count;
                     seenStrips[strip] = stripOrd;
@@ -535,11 +533,9 @@ namespace Lucene.Net.Analysis.Hunspell
                     affixArg = cleaned.ToString();
                 }
 
-                IList<char?> list = affixes.ContainsKey(affixArg) ? affixes[affixArg] : null;
-                if (list == null)
+                if (!affixes.TryGetValue(affixArg, out IList<char?> list) || list == null)
                 {
-                    list = new List<char?>();
-                    affixes[affixArg] = list;
+                    affixes[affixArg] = list = new List<char?>();
                 }
 
                 list.Add((char)currentAffix);
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Nl/DutchStemmer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Nl/DutchStemmer.cs
index 43ef3fc..0e9ccd8 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Nl/DutchStemmer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Nl/DutchStemmer.cs
@@ -60,16 +60,9 @@ namespace Lucene.Net.Analysis.Nl
             {
                 return term;
             }
-            if (_stemDict != null && _stemDict.ContainsKey(term))
+            if (_stemDict != null && _stemDict.TryGetValue(term, out string value))
             {
-                if (_stemDict[term] is string)
-                {
-                    return (string)_stemDict[term];
-                }
-                else
-                {
-                    return null;
-                }
+                return value;
             }
 
             // Reset the StringBuilder.
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupFilterFactory.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupFilterFactory.cs
index e446ad2..d7648cc 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupFilterFactory.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupFilterFactory.cs
@@ -41,7 +41,7 @@ namespace Lucene.Net.Analysis.Pattern
             : base(args)
         {
             pattern = GetPattern(args, "pattern");
-            preserveOriginal = args.ContainsKey("preserve_original") ? bool.Parse(args["preserve_original"]) : true;
+            preserveOriginal = args.TryGetValue("preserve_original", out string value) ? bool.Parse(value) : true;
         }
 
         public override TokenStream Create(TokenStream input)
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Query/QueryAutoStopWordAnalyzer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Query/QueryAutoStopWordAnalyzer.cs
index 70f432a..fa6f338 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Query/QueryAutoStopWordAnalyzer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Query/QueryAutoStopWordAnalyzer.cs
@@ -151,8 +151,7 @@ namespace Lucene.Net.Analysis.Query
 
         protected override TokenStreamComponents WrapComponents(string fieldName, TokenStreamComponents components)
         {
-            var stopWords = stopWordsPerField.ContainsKey(fieldName) ? stopWordsPerField[fieldName] : null;
-            if (stopWords == null)
+            if (!stopWordsPerField.TryGetValue(fieldName, out HashSet<string> stopWords) || stopWords == null)
             {
                 return components;
             }
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilterFactory.cs b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilterFactory.cs
index 457b729..78c253f 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilterFactory.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilterFactory.cs
@@ -73,7 +73,7 @@ namespace Lucene.Net.Analysis.Synonym
             {
                 // check if you use the new optional arg "format". this makes no sense for the old one, 
                 // as its wired to solr's synonyms format only.
-                if (args.ContainsKey("format") && !args["format"].Equals("solr", StringComparison.Ordinal))
+                if (args.TryGetValue("format", out string value) && !value.Equals("solr", StringComparison.Ordinal))
                 {
                     throw new System.ArgumentException("You must specify luceneMatchVersion >= 3.4 to use alternate synonyms formats");
                 }
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs
index 16f0ea0..84e4c33 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs
@@ -197,8 +197,7 @@ namespace Lucene.Net.Analysis.Synonym
                     //System.out.println("  output=" + output + " new ord=" + ord);
                 }
 
-                MapEntry e = workingSet.ContainsKey(input) ? workingSet[input] : null;
-                if (e == null)
+                if (!workingSet.TryGetValue(input, out MapEntry e) || e == null)
                 {
                     e = new MapEntry();
                     workingSet[CharsRef.DeepCopyOf(input)] = e; // make a copy, since we will keep around in our map
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs
index 893404a..88fd5b5 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs
@@ -767,10 +767,10 @@ namespace Lucene.Net.Analysis.Util
             {
                 while (iter.MoveNext())
                 {
-                    if (!this.ContainsKey(iter.Current.Key))
+                    if (!this.TryGetValue(iter.Current.Key, out TValue value))
                         return false;
 
-                    if (!EqualityComparer<TValue>.Default.Equals(this[iter.Current.Key], iter.Current.Value))
+                    if (!EqualityComparer<TValue>.Default.Equals(value, iter.Current.Value))
                         return false;
                 }
             }
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharacterUtils.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharacterUtils.cs
index 645618c..ffda963 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharacterUtils.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharacterUtils.cs
@@ -194,15 +194,15 @@ namespace Lucene.Net.Analysis.Util
             {
                 throw new System.ArgumentException("srcLen must be >= 0");
             }
-            int codePointCount_Renamed = 0;
+            int codePointCount = 0;
             for (int i = 0; i < srcLen; )
             {
                 int cp = CodePointAt(src, srcOff + i, srcOff + srcLen);
                 int charCount = Character.CharCount(cp);
-                dest[destOff + codePointCount_Renamed++] = cp;
+                dest[destOff + codePointCount++] = cp;
                 i += charCount;
             }
-            return codePointCount_Renamed;
+            return codePointCount;
         }
 
         /// <summary>
diff --git a/src/Lucene.Net.Analysis.Phonetic/Language/DaitchMokotoffSoundex.cs b/src/Lucene.Net.Analysis.Phonetic/Language/DaitchMokotoffSoundex.cs
index c0de1eb..1e51694 100644
--- a/src/Lucene.Net.Analysis.Phonetic/Language/DaitchMokotoffSoundex.cs
+++ b/src/Lucene.Net.Analysis.Phonetic/Language/DaitchMokotoffSoundex.cs
@@ -432,9 +432,9 @@ namespace Lucene.Net.Analysis.Phonetic.Language
                 }
 
                 ch = char.ToLowerInvariant(ch);
-                if (folding && FOLDINGS.ContainsKey(ch))
+                if (folding && FOLDINGS.TryGetValue(ch, out char newChar))
                 {
-                    ch = FOLDINGS[ch];
+                    ch = newChar;
                 }
                 sb.Append(ch);
             }
diff --git a/src/Lucene.Net.Analysis.SmartCn/Hhmm/BiSegGraph.cs b/src/Lucene.Net.Analysis.SmartCn/Hhmm/BiSegGraph.cs
index 6c2923e..772745f 100644
--- a/src/Lucene.Net.Analysis.SmartCn/Hhmm/BiSegGraph.cs
+++ b/src/Lucene.Net.Analysis.SmartCn/Hhmm/BiSegGraph.cs
@@ -130,10 +130,7 @@ namespace Lucene.Net.Analysis.Cn.Smart.Hhmm
         /// <returns><c>true</c> if a token pair exists</returns>
         public virtual bool IsToExist(int to)
         {
-            //return tokenPairListTable.get(Integer.valueOf(to)) != null;
-            //return tokenPairListTable.ContainsKey(to) && tokenPairListTable[to] != null;
-            IList<SegTokenPair> result;
-            return tokenPairListTable.TryGetValue(to, out result) && result != null;
+            return tokenPairListTable.TryGetValue(to, out IList<SegTokenPair> result) && result != null;
         }
 
         /// <summary>
diff --git a/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/Optimizer.cs b/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/Optimizer.cs
index ed97f98..29673c4 100644
--- a/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/Optimizer.cs
+++ b/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/Optimizer.cs
@@ -128,10 +128,9 @@ namespace Egothor.Stemmer
             foreach (char ch in master.cells.Keys)
             {
                 // XXX also must handle Cnt and Skip !!
-                Cell a = master.cells.ContainsKey(ch) ? master.cells[ch] : null;
-                Cell b = existing.cells.ContainsKey(ch) ? existing.cells[ch] : null;
+                master.cells.TryGetValue(ch, out Cell a);
 
-                Cell s = (b == null) ? new Cell(a) : Merge(a, b);
+                Cell s = !existing.cells.TryGetValue(ch, out Cell b) || (b == null) ? new Cell(a) : Merge(a, b);
                 if (s == null)
                 {
                     return null;
diff --git a/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/Row.cs b/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/Row.cs
index 39cb7d1..88b0e13 100644
--- a/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/Row.cs
+++ b/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/Row.cs
@@ -323,7 +323,8 @@ namespace Egothor.Stemmer
 
         internal Cell At(char index)
         {
-            return cells.ContainsKey(index) ? cells[index] : null;
+            cells.TryGetValue(index, out Cell value);
+            return value;
         }
     }
 }
diff --git a/src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs b/src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs
index c1c63ac..a191dd0 100644
--- a/src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs
+++ b/src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs
@@ -139,14 +139,8 @@ namespace Lucene.Net.Benchmarks.Quality.Trec
             for (int i = 0; i < qq.Length; i++)
             {
                 string id = qq[i].QueryID;
-                if (missingQueries.ContainsKey(id))
-                {
-                    missingQueries.Remove(id);
-                }
-                else
-                {
+                if (!missingQueries.Remove(id))
                     missingJudgements.Add(id);
-                }
             }
             bool isValid = true;
             if (missingJudgements.Count > 0)
diff --git a/src/Lucene.Net.Benchmark/Support/Sax/Helpers/NamespaceSupport.cs b/src/Lucene.Net.Benchmark/Support/Sax/Helpers/NamespaceSupport.cs
index 42e5564..06470d6 100644
--- a/src/Lucene.Net.Benchmark/Support/Sax/Helpers/NamespaceSupport.cs
+++ b/src/Lucene.Net.Benchmark/Support/Sax/Helpers/NamespaceSupport.cs
@@ -644,9 +644,9 @@ namespace Sax.Helpers
                 // Start by looking in the cache, and
                 // return immediately if the name
                 // is already known in this content
-                if (table.ContainsKey(qName))
+                if (table.TryGetValue(qName, out string[] value))
                 {
-                    return (string[])table[qName];
+                    return value;
                 }
 
                 // We haven't seen this name in this
diff --git a/src/Lucene.Net.Classification/KNearestNeighborClassifier.cs b/src/Lucene.Net.Classification/KNearestNeighborClassifier.cs
index 5122462..1f5e3c0 100644
--- a/src/Lucene.Net.Classification/KNearestNeighborClassifier.cs
+++ b/src/Lucene.Net.Classification/KNearestNeighborClassifier.cs
@@ -97,9 +97,9 @@ namespace Lucene.Net.Classification
             foreach (ScoreDoc scoreDoc in topDocs.ScoreDocs)
             {
                 BytesRef cl = new BytesRef(_indexSearcher.Doc(scoreDoc.Doc).GetField(_classFieldName).GetStringValue());
-                if (classCounts.ContainsKey(cl))
+                if (classCounts.TryGetValue(cl, out int value))
                 {
-                    classCounts[cl] = classCounts[cl] + 1;
+                    classCounts[cl] = value + 1;
                 }
                 else
                 {
diff --git a/src/Lucene.Net.Expressions/JS/JavascriptCompiler.cs b/src/Lucene.Net.Expressions/JS/JavascriptCompiler.cs
index ddfaaf9..de47309 100644
--- a/src/Lucene.Net.Expressions/JS/JavascriptCompiler.cs
+++ b/src/Lucene.Net.Expressions/JS/JavascriptCompiler.cs
@@ -261,16 +261,11 @@ namespace Lucene.Net.Expressions.JS
                     }
                 case JavascriptParser.NAMESPACE_ID:
                     {
-                        int index;
-                        if (externalsMap.ContainsKey(text))
+                        if (!externalsMap.TryGetValue(text, out int index))
                         {
-                            index = externalsMap[text];
-                        }
-                        else
-                        {
-                            index = externalsMap.Count;
-                            externalsMap[text] = index;
+                            externalsMap[text] = index = externalsMap.Count;
                         }
+
                         gen.Emit(OpCodes.Nop);
 
                         gen.Emit(OpCodes.Ldarg_2);
diff --git a/src/Lucene.Net.Facet/FacetsConfig.cs b/src/Lucene.Net.Facet/FacetsConfig.cs
index d800319..1030b73 100644
--- a/src/Lucene.Net.Facet/FacetsConfig.cs
+++ b/src/Lucene.Net.Facet/FacetsConfig.cs
@@ -160,14 +160,14 @@ namespace Lucene.Net.Facet
         {
             lock (this)
             {
-                if (!fieldTypes.ContainsKey(dimName))
+                // LUCENENET: Eliminated extra lookup by using TryGetValue instead of ContainsKey
+                if (!fieldTypes.TryGetValue(dimName, out DimConfig fieldType))
                 {
-                    var ft = new DimConfig { IsHierarchical = v };
-                    fieldTypes[dimName] = ft;
+                    fieldTypes[dimName] = new DimConfig { IsHierarchical = v };
                 }
                 else
                 {
-                    fieldTypes[dimName].IsHierarchical = v;
+                    fieldType.IsHierarchical = v;
                 }
             }
         }
@@ -180,14 +180,14 @@ namespace Lucene.Net.Facet
         {
             lock (this)
             {
-                if (!fieldTypes.ContainsKey(dimName))
+                // LUCENENET: Eliminated extra lookup by using TryGetValue instead of ContainsKey
+                if (!fieldTypes.TryGetValue(dimName, out DimConfig fieldType))
                 {
-                    var ft = new DimConfig { IsMultiValued = v };
-                    fieldTypes[dimName] = ft;
+                    fieldTypes[dimName] = new DimConfig { IsMultiValued = v };
                 }
                 else
                 {
-                    fieldTypes[dimName].IsMultiValued = v;
+                    fieldType.IsMultiValued = v;
                 }
             }
         }
@@ -201,14 +201,14 @@ namespace Lucene.Net.Facet
         {
             lock (this)
             {
-                if (!fieldTypes.ContainsKey(dimName))
+                // LUCENENET: Eliminated extra lookup by using TryGetValue instead of ContainsKey
+                if (!fieldTypes.TryGetValue(dimName, out DimConfig fieldType))
                 {
-                    var ft = new DimConfig { RequireDimCount = v };
-                    fieldTypes[dimName] = ft;
+                    fieldTypes[dimName] = new DimConfig { RequireDimCount = v };
                 }
                 else
                 {
-                    fieldTypes[dimName].RequireDimCount = v;
+                    fieldType.RequireDimCount = v;
                 }
             }
         }
@@ -222,14 +222,14 @@ namespace Lucene.Net.Facet
         {
             lock (this)
             {
-                if (!fieldTypes.ContainsKey(dimName))
+                // LUCENENET: Eliminated extra lookup by using TryGetValue instead of ContainsKey
+                if (!fieldTypes.TryGetValue(dimName, out DimConfig fieldType))
                 {
-                    var ft = new DimConfig { IndexFieldName = indexFieldName };
-                    fieldTypes[dimName] = ft;
+                    fieldTypes[dimName] = new DimConfig { IndexFieldName = indexFieldName };
                 }
                 else
                 {
-                    fieldTypes[dimName].IndexFieldName = indexFieldName;
+                    fieldType.IndexFieldName = indexFieldName;
                 }
             }
         }
@@ -237,13 +237,7 @@ namespace Lucene.Net.Facet
         /// <summary>
         /// Returns map of field name to <see cref="DimConfig"/>.
         /// </summary>
-        public virtual IDictionary<string, DimConfig> DimConfigs
-        {
-            get
-            {
-                return fieldTypes;
-            }
-        }
+        public virtual IDictionary<string, DimConfig> DimConfigs => fieldTypes;
 
         private static void CheckSeen(HashSet<string> seenDims, string dim)
         {
diff --git a/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs b/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
index 2c52168..439c105 100644
--- a/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
@@ -202,9 +202,9 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
             {
                 string epochStr = null;
                 IDictionary<string, string> commitData = ReadCommitData(directory);
-                if (commitData != null && commitData.ContainsKey(INDEX_EPOCH))
+                if (commitData != null && commitData.TryGetValue(INDEX_EPOCH, out string value))
                 {
-                    epochStr = commitData[INDEX_EPOCH];
+                    epochStr = value;
                 }
                 // no commit data, or no epoch in it means an old taxonomy, so set its epoch to 1, for lack
                 // of a better value.
diff --git a/src/Lucene.Net.Grouping/AbstractSecondPassGroupingCollector.cs b/src/Lucene.Net.Grouping/AbstractSecondPassGroupingCollector.cs
index 396efc6..18eb85a 100644
--- a/src/Lucene.Net.Grouping/AbstractSecondPassGroupingCollector.cs
+++ b/src/Lucene.Net.Grouping/AbstractSecondPassGroupingCollector.cs
@@ -131,7 +131,7 @@ namespace Lucene.Net.Search.Grouping
             float maxScore = float.MinValue;
             foreach (var group in groups)
             {
-                AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue> groupDocs = m_groupMap.ContainsKey(group.GroupValue) ? m_groupMap[group.GroupValue] : null;
+                AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue> groupDocs = m_groupMap[group.GroupValue];
                 TopDocs topDocs = groupDocs.Collector.GetTopDocs(withinGroupOffset, maxDocsPerGroup);
                 groupDocsResult[groupIDX++] = new GroupDocs<TGroupValue>(float.NaN,
                                                                               topDocs.MaxScore,
diff --git a/src/Lucene.Net.Grouping/SearchGroup.cs b/src/Lucene.Net.Grouping/SearchGroup.cs
index c03d93c..a34e24b 100644
--- a/src/Lucene.Net.Grouping/SearchGroup.cs
+++ b/src/Lucene.Net.Grouping/SearchGroup.cs
@@ -331,8 +331,7 @@ namespace Lucene.Net.Search.Grouping
                 while (shard.Iter.MoveNext())
                 {
                     ISearchGroup<T> group = shard.Next();
-                    MergedGroup<T> mergedGroup = groupsSeen.ContainsKey(group.GroupValue) ? groupsSeen[group.GroupValue] : null;
-                    bool isNew = mergedGroup == null;
+                    bool isNew = !groupsSeen.TryGetValue(group.GroupValue, out MergedGroup<T> mergedGroup) || mergedGroup == null;
                     //System.out.println("    next group=" + (group.groupValue == null ? "null" : ((BytesRef) group.groupValue).utf8ToString()) + " sort=" + Arrays.toString(group.sortValues));
 
                     if (isNew)
diff --git a/src/Lucene.Net.QueryParser/Classic/QueryParserBase.cs b/src/Lucene.Net.QueryParser/Classic/QueryParserBase.cs
index 0dcffee..cafc31f 100644
--- a/src/Lucene.Net.QueryParser/Classic/QueryParserBase.cs
+++ b/src/Lucene.Net.QueryParser/Classic/QueryParserBase.cs
@@ -365,13 +365,13 @@ namespace Lucene.Net.QueryParsers.Classic
                 return this.dateResolution;
             }
 
-            if (!fieldToDateResolution.ContainsKey(fieldName))
+            if (!fieldToDateResolution.TryGetValue(fieldName, out DateTools.Resolution resolution))
             {
                 // no date resolutions set for the given field; return default date resolution instead
                 return this.dateResolution;
             }
 
-            return fieldToDateResolution[fieldName];
+            return resolution;
         }
 
         /// <summary>
diff --git a/src/Lucene.Net.QueryParser/Ext/Extensions.cs b/src/Lucene.Net.QueryParser/Ext/Extensions.cs
index 195940f..44c7d9b 100644
--- a/src/Lucene.Net.QueryParser/Ext/Extensions.cs
+++ b/src/Lucene.Net.QueryParser/Ext/Extensions.cs
@@ -86,17 +86,14 @@ namespace Lucene.Net.QueryParsers.Ext
         /// <code>null</code> if no extension can be found for the key.</returns>
         public ParserExtension GetExtension(string key)
         {
-            if (key == null || !this.extensions.ContainsKey(key)) return null;
-            return this.extensions[key];
+            if (key == null || !this.extensions.TryGetValue(key, out ParserExtension value)) return null;
+            return value;
         }
 
         /// <summary>
         /// Returns the extension field delimiter
         /// </summary>
-        public virtual char ExtensionFieldDelimiter
-        {
-            get { return extensionFieldDelimiter; }
-        }
+        public virtual char ExtensionFieldDelimiter => extensionFieldDelimiter;
 
         /// <summary>
         /// Splits a extension field and returns the field / extension part as a
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QueryNodeImpl.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QueryNodeImpl.cs
index b779f9a..256f625 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QueryNodeImpl.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QueryNodeImpl.cs
@@ -194,6 +194,8 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
             return this.tags[CultureInfo.InvariantCulture.TextInfo.ToLower(tagName)];
         }
 
+        // LUCENENET TODO: API - Create TryGetTag method to combine the above 2 operations
+
         private IQueryNode parent = null;
 
         private void SetParent(IQueryNode parent)
diff --git a/src/Lucene.Net.QueryParser/Surround/Query/SpanNearClauseFactory.cs b/src/Lucene.Net.QueryParser/Surround/Query/SpanNearClauseFactory.cs
index 8fbc219..6bcd67b 100644
--- a/src/Lucene.Net.QueryParser/Surround/Query/SpanNearClauseFactory.cs
+++ b/src/Lucene.Net.QueryParser/Surround/Query/SpanNearClauseFactory.cs
@@ -86,8 +86,8 @@ namespace Lucene.Net.QueryParsers.Surround.Query
         protected virtual void AddSpanQueryWeighted(SpanQuery sq, float weight)
         {
             float w;
-            if (weightBySpanQuery.ContainsKey(sq))
-                w = weightBySpanQuery[sq] + weight;
+            if (weightBySpanQuery.TryGetValue(sq, out float weightValue))
+                w = weightValue + weight;
             else
                 w = weight;
             weightBySpanQuery[sq] = w;
diff --git a/src/Lucene.Net.TestFramework/Analysis/BaseTokenStreamTestCase.cs b/src/Lucene.Net.TestFramework/Analysis/BaseTokenStreamTestCase.cs
index 9717393..d9cba86 100644
--- a/src/Lucene.Net.TestFramework/Analysis/BaseTokenStreamTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Analysis/BaseTokenStreamTestCase.cs
@@ -305,7 +305,7 @@ namespace Lucene.Net.Analysis
 
                             int posLength = posLengthAtt.PositionLength;
 
-                            if (!posToStartOffset.ContainsKey(pos))
+                            if (!posToStartOffset.TryGetValue(pos, out int? oldStartOffset))
                             {
                                 // First time we've seen a token leaving from this position:
                                 posToStartOffset[pos] = startOffset;
@@ -316,12 +316,12 @@ namespace Lucene.Net.Analysis
                                 // We've seen a token leaving from this position
                                 // before; verify the startOffset is the same:
                                 //System.out.println("  + vs " + pos + " -> " + startOffset);
-                                Assert.AreEqual((int)posToStartOffset[pos], startOffset, "pos=" + pos + " posLen=" + posLength + " token=" + termAtt);
+                                Assert.AreEqual(oldStartOffset.GetValueOrDefault(), startOffset, "pos=" + pos + " posLen=" + posLength + " token=" + termAtt);
                             }
 
                             int endPos = pos + posLength;
 
-                            if (!posToEndOffset.ContainsKey(endPos))
+                            if (!posToEndOffset.TryGetValue(endPos, out int? oldEndOffset))
                             {
                                 // First time we've seen a token arriving to this position:
                                 posToEndOffset[endPos] = endOffset;
@@ -332,7 +332,7 @@ namespace Lucene.Net.Analysis
                                 // We've seen a token arriving to this position
                                 // before; verify the endOffset is the same:
                                 //System.out.println("  + ve " + endPos + " -> " + endOffset);
-                                Assert.AreEqual((int)posToEndOffset[endPos], endOffset, "pos=" + pos + " posLen=" + posLength + " token=" + termAtt);
+                                Assert.AreEqual(oldEndOffset.GetValueOrDefault(), endOffset, "pos=" + pos + " posLen=" + posLength + " token=" + termAtt);
                             }
                         }
                     }
diff --git a/src/Lucene.Net.TestFramework/Analysis/ValidatingTokenFilter.cs b/src/Lucene.Net.TestFramework/Analysis/ValidatingTokenFilter.cs
index f0e0de2..238c317 100644
--- a/src/Lucene.Net.TestFramework/Analysis/ValidatingTokenFilter.cs
+++ b/src/Lucene.Net.TestFramework/Analysis/ValidatingTokenFilter.cs
@@ -119,7 +119,7 @@ namespace Lucene.Net.Analysis
 
             if (offsetAtt != null && posIncAtt != null && offsetsAreCorrect)
             {
-                if (!posToStartOffset.ContainsKey(pos))
+                if (!posToStartOffset.TryGetValue(pos, out int oldStartOffset))
                 {
                     // First time we've seen a token leaving from this position:
                     posToStartOffset[pos] = startOffset;
@@ -130,7 +130,6 @@ namespace Lucene.Net.Analysis
                     // We've seen a token leaving from this position
                     // before; verify the startOffset is the same:
                     //System.out.println("  + vs " + pos + " -> " + startOffset);
-                    int oldStartOffset = posToStartOffset[pos];
                     if (oldStartOffset != startOffset)
                     {
                         throw new Exception(name + ": inconsistent startOffset at pos=" + pos + ": " + oldStartOffset + " vs " + startOffset + "; token=" + termAtt);
@@ -139,7 +138,7 @@ namespace Lucene.Net.Analysis
 
                 int endPos = pos + posLen;
 
-                if (!posToEndOffset.ContainsKey(endPos))
+                if (!posToEndOffset.TryGetValue(endPos, out int oldEndOffset))
                 {
                     // First time we've seen a token arriving to this position:
                     posToEndOffset[endPos] = endOffset;
@@ -150,7 +149,6 @@ namespace Lucene.Net.Analysis
                     // We've seen a token arriving to this position
                     // before; verify the endOffset is the same:
                     //System.out.println("  + ve " + endPos + " -> " + endOffset);
-                    int oldEndOffset = posToEndOffset[endPos];
                     if (oldEndOffset != endOffset)
                     {
                         throw new Exception(name + ": inconsistent endOffset at pos=" + endPos + ": " + oldEndOffset + " vs " + endOffset + "; token=" + termAtt);
diff --git a/src/Lucene.Net.TestFramework/Index/BaseIndexFileFormatTestCase.cs b/src/Lucene.Net.TestFramework/Index/BaseIndexFileFormatTestCase.cs
index 9c1da79..739ee68 100644
--- a/src/Lucene.Net.TestFramework/Index/BaseIndexFileFormatTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Index/BaseIndexFileFormatTestCase.cs
@@ -87,7 +87,7 @@ namespace Lucene.Net.Index
             foreach (string file in d.ListAll())
             {
                 string ext = IndexFileNames.GetExtension(file);
-                long previousLength = bytesUsedByExtension.ContainsKey(ext) ? bytesUsedByExtension[ext] : 0;
+                long previousLength = bytesUsedByExtension.TryGetValue(ext, out long length) ? length : 0;
                 bytesUsedByExtension[ext] = previousLength + d.FileLength(file);
             }
             foreach (string item in ExcludedExtensionsFromByteCounts)
diff --git a/src/Lucene.Net.TestFramework/Index/BaseTermVectorsFormatTestCase.cs b/src/Lucene.Net.TestFramework/Index/BaseTermVectorsFormatTestCase.cs
index 835734d..37d3126 100644
--- a/src/Lucene.Net.TestFramework/Index/BaseTermVectorsFormatTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Index/BaseTermVectorsFormatTestCase.cs
@@ -340,24 +340,24 @@ namespace Lucene.Net.Index
                 startOffsetToTerms = new Dictionary<int?, ISet<int?>>(len);
                 for (int i = 0; i < len; ++i)
                 {
-                    if (!positionToTerms.ContainsKey(positions[i]))
+                    if (!positionToTerms.TryGetValue(positions[i], out ISet<int?> positionTerms))
                     {
-                        positionToTerms[positions[i]] = new HashSet<int?>();//size1
+                        positionToTerms[positions[i]] = positionTerms = NewHashSet<int?>(1);
                     }
-                    positionToTerms[positions[i]].Add(i);
-                    if (!startOffsetToTerms.ContainsKey(startOffsets[i]))
+                    positionTerms.Add(i);
+                    if (!startOffsetToTerms.TryGetValue(startOffsets[i], out ISet<int?> startOffsetTerms))
                     {
-                        startOffsetToTerms[startOffsets[i]] = new HashSet<int?>();//size1
+                        startOffsetToTerms[startOffsets[i]] = startOffsetTerms = NewHashSet<int?>(1);
                     }
-                    startOffsetToTerms[startOffsets[i]].Add(i);
+                    startOffsetTerms.Add(i);
                 }
 
                 freqs = new Dictionary<string, int?>();
                 foreach (string term in terms)
                 {
-                    if (freqs.ContainsKey(term))
+                    if (freqs.TryGetValue(term, out int? freq))
                     {
-                        freqs[term] = freqs[term] + 1;
+                        freqs[term] = freq + 1;
                     }
                     else
                     {
@@ -373,6 +373,17 @@ namespace Lucene.Net.Index
                 pAtt = AddAttribute<IPayloadAttribute>();
             }
 
+            // LUCENENET: Since capacity wasn't added until .NET Standard 2.1,
+            // this wrapper ensures we can pass it even if it is ignored
+            private ISet<T> NewHashSet<T>(int capacity)
+            {
+#if FEATURE_HASHSET_CAPACITY
+                return new HashSet<T>(capacity);
+#else
+                return new HashSet<T>();
+#endif
+            }
+
             public virtual bool HasPayloads()
             {
                 foreach (BytesRef payload in payloads)
diff --git a/src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs b/src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs
index bd36c17..1d3d94e 100644
--- a/src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs
+++ b/src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs
@@ -827,8 +827,7 @@ namespace Lucene.Net.Util.Fst
                 for (int idx = 0; idx <= pair.Input.Length; idx++)
                 {
                     scratch.Length = idx;
-                    CountMinOutput<T> cmo = prefixes.ContainsKey(scratch) ? prefixes[scratch] : null;
-                    if (cmo == null)
+                    if (!prefixes.TryGetValue(scratch, out CountMinOutput<T> cmo) || cmo == null)
                     {
                         cmo = new CountMinOutput<T>();
                         cmo.Count = 1;
@@ -893,7 +892,7 @@ namespace Lucene.Net.Util.Fst
                         // consult our parent
                         scratch.Length = prefix.Length - 1;
                         Array.Copy(prefix.Int32s, prefix.Offset, scratch.Int32s, 0, scratch.Length);
-                        CountMinOutput<T> cmo2 = prefixes.ContainsKey(scratch) ? prefixes[scratch] : null;
+                        prefixes.TryGetValue(scratch, out CountMinOutput<T> cmo2);
                         //System.out.println("    parent count = " + (cmo2 == null ? -1 : cmo2.count));
                         keep = cmo2 != null && ((prune2 > 1 && cmo2.Count >= prune2) || (prune2 == 1 && (cmo2.Count >= 2 || prefix.Length <= 1)));
                     }
@@ -920,8 +919,7 @@ namespace Lucene.Net.Util.Fst
                     scratch.Length--;
                     while (scratch.Length >= 0)
                     {
-                        CountMinOutput<T> cmo2 = prefixes.ContainsKey(scratch) ? prefixes[scratch] : null;
-                        if (cmo2 != null)
+                        if (prefixes.TryGetValue(scratch, out CountMinOutput<T> cmo2) && cmo2 != null)
                         {
                             //System.out.println("    clear isLeaf " + inputToString(inputMode, scratch));
                             cmo2.IsLeaf = false;
@@ -965,7 +963,7 @@ namespace Lucene.Net.Util.Fst
                 {
                     Console.WriteLine("  fstEnum.next prefix=" + InputToString(inputMode, current.Input, false) + " output=" + outputs.OutputToString(current.Output));
                 }
-                CountMinOutput<T> cmo = prefixes.ContainsKey(current.Input) ? prefixes[current.Input] : null;
+                prefixes.TryGetValue(current.Input, out CountMinOutput<T> cmo);
                 Assert.IsNotNull(cmo);
                 Assert.IsTrue(cmo.IsLeaf || cmo.IsFinal);
                 //if (cmo.isFinal && !cmo.isLeaf) {
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs
index 9512f1f..0e8d27a 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs
@@ -936,14 +936,12 @@ namespace Lucene.Net.Analysis.Core
 
             private bool Broken(ConstructorInfo ctor, object[] args)
             {
-                IPredicate<object[]> pred = brokenConstructors.ContainsKey(ctor) ? brokenConstructors[ctor] : null;
-                return pred != null && pred.Apply(args);
+                return brokenConstructors.TryGetValue(ctor, out IPredicate<object[]> pred) && pred != null && pred.Apply(args);
             }
 
             private bool BrokenOffsets(ConstructorInfo ctor, object[] args)
             {
-                IPredicate<object[]> pred = brokenOffsetsConstructors.ContainsKey(ctor) ? brokenOffsetsConstructors[ctor] : null;
-                return pred != null && pred.Apply(args);
+                return brokenOffsetsConstructors.TryGetValue(ctor, out IPredicate<object[]> pred) && pred != null && pred.Apply(args);
             }
 
             // create a new random tokenizer from classpath
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMapFilter.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMapFilter.cs
index 7dd932d..0dd0057 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMapFilter.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMapFilter.cs
@@ -485,8 +485,7 @@ namespace Lucene.Net.Analysis.Synonym
             for (int synIDX = 0; synIDX < numSyn; synIDX++)
             {
                 string synIn = GetRandomString('a', alphabetSize, TestUtil.NextInt32(Random, 1, 5)).Trim();
-                OneSyn s = synMap.ContainsKey(synIn) ? synMap[synIn] : null;
-                if (s == null)
+                if (!synMap.TryGetValue(synIn, out OneSyn s) || s == null)
                 {
                     s = new OneSyn();
                     s.@in = synIn;
diff --git a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetCounts.cs b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetCounts.cs
index 707cad3..3ae7d05 100644
--- a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetCounts.cs
+++ b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetCounts.cs
@@ -848,8 +848,7 @@ namespace Lucene.Net.Facet.Taxonomy
                         {
                             if (doc.dims[j] != null)
                             {
-                                int? v = expectedCounts[j].ContainsKey(doc.dims[j]) ? expectedCounts[j][doc.dims[j]] : null;
-                                if (v == null)
+                                if (!expectedCounts[j].TryGetValue(doc.dims[j], out int? v) || v == null)
                                 {
                                     expectedCounts[j][doc.dims[j]] = 1;
                                 }
diff --git a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs
index 1430148..39d3822 100644
--- a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs
+++ b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs
@@ -569,8 +569,7 @@ namespace Lucene.Net.Facet.Taxonomy
                         {
                             if (doc.dims[j] != null)
                             {
-                                float? v = expectedValues[j].ContainsKey(doc.dims[j]) ? expectedValues[j][doc.dims[j]] : null;
-                                if (v == null)
+                                if (!expectedValues[j].TryGetValue(doc.dims[j], out float? v) || v == null)
                                 {
                                     expectedValues[j][doc.dims[j]] = doc.value;
                                 }
diff --git a/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs b/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs
index a876658..3cfb23d 100644
--- a/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs
+++ b/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs
@@ -489,14 +489,14 @@ namespace Lucene.Net.Search.Grouping
                     continue;
                 }
 
-                if (!groupHeads.ContainsKey(groupDoc.group))
+                if (!groupHeads.TryGetValue(groupDoc.group, out List<GroupDoc> grouphead))
                 {
                     List<GroupDoc> list = new List<GroupDoc>();
                     list.Add(groupDoc);
                     groupHeads[groupDoc.group] = list;
                     continue;
                 }
-                groupHeads[groupDoc.group].Add(groupDoc);
+                grouphead.Add(groupDoc);
             }
 
             int[] allGroupHeads = new int[groupHeads.Count];
diff --git a/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs b/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
index 154dc15..9715d0a 100644
--- a/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
+++ b/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
@@ -633,11 +633,10 @@ namespace Lucene.Net.Search.Grouping
                 }
 
                 string contentStr = contentBrs[random.nextInt(contentBrs.Length)];
-                if (!searchTermToFacetToGroups.ContainsKey(contentStr))
+                if (!searchTermToFacetToGroups.TryGetValue(contentStr, out HashMap<string, ISet<string>> facetToGroups))
                 {
-                    searchTermToFacetToGroups[contentStr] = new HashMap<string, ISet<string>>();
+                    searchTermToFacetToGroups[contentStr] = facetToGroups = new HashMap<string, ISet<string>>();
                 }
-                IDictionary<string, ISet<string>> facetToGroups = searchTermToFacetToGroups[contentStr];
 
                 List<string> facetVals = new List<string>();
                 if (useDv || random.nextInt(24) != 18)
@@ -646,11 +645,10 @@ namespace Lucene.Net.Search.Grouping
                     {
                         string facetValue = facetValues[random.nextInt(facetValues.size())];
                         uniqueFacetValues.Add(facetValue);
-                        if (!facetToGroups.ContainsKey(facetValue))
+                        if (!facetToGroups.TryGetValue(facetValue, out ISet<string> groupsInFacet))
                         {
-                            facetToGroups[facetValue] = new HashSet<string>();
+                            facetToGroups[facetValue] = groupsInFacet = new HashSet<string>();
                         }
-                        ISet<string> groupsInFacet = facetToGroups[facetValue];
                         groupsInFacet.add(groupValue);
                         if (groupsInFacet.size() > facetWithMostGroups)
                         {
@@ -666,11 +664,10 @@ namespace Lucene.Net.Search.Grouping
                         {
                             string facetValue = facetValues[random.nextInt(facetValues.size())];
                             uniqueFacetValues.Add(facetValue);
-                            if (!facetToGroups.ContainsKey(facetValue))
+                            if (!facetToGroups.TryGetValue(facetValue, out ISet<string> groupsInFacet))
                             {
-                                facetToGroups[facetValue] = new HashSet<string>();
+                                facetToGroups[facetValue] = groupsInFacet = new HashSet<string>();
                             }
-                            ISet<string> groupsInFacet = facetToGroups[facetValue];
                             groupsInFacet.add(groupValue);
                             if (groupsInFacet.size() > facetWithMostGroups)
                             {
@@ -684,11 +681,10 @@ namespace Lucene.Net.Search.Grouping
                 else
                 {
                     uniqueFacetValues.Add(null);
-                    if (!facetToGroups.ContainsKey(null))
+                    if (!facetToGroups.TryGetValue(null, out ISet<string> groupsInFacet))
                     {
-                        facetToGroups.Put(null, new HashSet<string>());
+                        facetToGroups[null] = groupsInFacet = new HashSet<string>();
                     }
-                    ISet<string> groupsInFacet = facetToGroups[null];
                     groupsInFacet.add(groupValue);
                     if (groupsInFacet.size() > facetWithMostGroups)
                     {
@@ -798,8 +794,7 @@ namespace Lucene.Net.Search.Grouping
                     continue;
                 }
 
-                ISet<string> groups = facetGroups.ContainsKey(facetValue) ? facetGroups[facetValue] : null;
-                int count = groups != null ? groups.size() : 0;
+                int count = facetGroups.TryGetValue(facetValue, out ISet<string> groups) && groups != null ? groups.size() : 0;
                 if (count >= minCount)
                 {
                     entries.Add(new TermGroupFacetCollector.FacetEntry(new BytesRef(facetValue), count));
diff --git a/src/Lucene.Net.Tests.Grouping/TestGrouping.cs b/src/Lucene.Net.Tests.Grouping/TestGrouping.cs
index 5ddd5ae..6647441 100644
--- a/src/Lucene.Net.Tests.Grouping/TestGrouping.cs
+++ b/src/Lucene.Net.Tests.Grouping/TestGrouping.cs
@@ -685,12 +685,12 @@ namespace Lucene.Net.Search.Grouping
 
             foreach (GroupDoc groupDoc in groupDocs)
             {
-                if (!groupMap.ContainsKey(groupDoc.group))
+                if (!groupMap.TryGetValue(groupDoc.group, out List<GroupDoc> docs))
                 {
                     groupValues.Add(groupDoc.group);
-                    groupMap.Put(groupDoc.group, new List<GroupDoc>());
+                    groupMap[groupDoc.group] = docs = new List<GroupDoc>();
                 }
-                groupMap[groupDoc.group].Add(groupDoc);
+                docs.Add(groupDoc);
             }
 
             RandomIndexWriter w = new RandomIndexWriter(
diff --git a/src/Lucene.Net.Tests.Highlighter/VectorHighlight/SimpleFragmentsBuilderTest.cs b/src/Lucene.Net.Tests.Highlighter/VectorHighlight/SimpleFragmentsBuilderTest.cs
index 52a44d1..9e36c2b 100644
--- a/src/Lucene.Net.Tests.Highlighter/VectorHighlight/SimpleFragmentsBuilderTest.cs
+++ b/src/Lucene.Net.Tests.Highlighter/VectorHighlight/SimpleFragmentsBuilderTest.cs
@@ -354,11 +354,11 @@ namespace Lucene.Net.Search.VectorHighlight
         private String getRandomValue(String[] randomValues, IDictionary<String, ISet<int>> valueToDocId, int docId)
         {
             String value = randomValues[Random.nextInt(randomValues.Length)];
-            if (!valueToDocId.ContainsKey(value))
+            if (!valueToDocId.TryGetValue(value, out ISet<int> docIds))
             {
-                valueToDocId.Put(value, new HashSet<int>());
+                valueToDocId[value] = docIds = new HashSet<int>();
             }
-            valueToDocId[value].Add(docId);
+            docIds.Add(docId);
             return value;
         }
 
diff --git a/src/Lucene.Net.Tests.Join/TestJoinUtil.cs b/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
index af98042..f98e52d 100644
--- a/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
+++ b/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
@@ -616,32 +616,32 @@ namespace Lucene.Net.Tests.Join
                     docs[i].LinkValues.Add(linkValue);
                     if (from)
                     {
-                        if (!context.FromDocuments.ContainsKey(linkValue))
+                        if (!context.FromDocuments.TryGetValue(linkValue, out IList<RandomDoc> fromDocs))
                         {
-                            context.FromDocuments[linkValue] = new List<RandomDoc>();
+                            context.FromDocuments[linkValue] = fromDocs = new List<RandomDoc>();
                         }
-                        if (!context.RandomValueFromDocs.ContainsKey(value))
+                        if (!context.RandomValueFromDocs.TryGetValue(value, out IList<RandomDoc> randomValueFromDocs))
                         {
-                            context.RandomValueFromDocs[value] = new List<RandomDoc>();
+                            context.RandomValueFromDocs[value] = randomValueFromDocs = new List<RandomDoc>();
                         }
 
-                        context.FromDocuments[linkValue].Add(docs[i]);
-                        context.RandomValueFromDocs[value].Add(docs[i]);
+                        fromDocs.Add(docs[i]);
+                        randomValueFromDocs.Add(docs[i]);
                         document.Add(NewTextField(Random, "from", linkValue, Field.Store.NO));
                     }
                     else
                     {
-                        if (!context.ToDocuments.ContainsKey(linkValue))
+                        if (!context.ToDocuments.TryGetValue(linkValue, out IList<RandomDoc> toDocuments))
                         {
-                            context.ToDocuments[linkValue] = new List<RandomDoc>();
+                            context.ToDocuments[linkValue] = toDocuments = new List<RandomDoc>();
                         }
-                        if (!context.RandomValueToDocs.ContainsKey(value))
+                        if (!context.RandomValueToDocs.TryGetValue(value, out IList<RandomDoc> randomValueToDocs))
                         {
-                            context.RandomValueToDocs[value] = new List<RandomDoc>();
+                            context.RandomValueToDocs[value] = randomValueToDocs = new List<RandomDoc>();
                         }
 
-                        context.ToDocuments[linkValue].Add(docs[i]);
-                        context.RandomValueToDocs[value].Add(docs[i]);
+                        toDocuments.Add(docs[i]);
+                        randomValueToDocs.Add(docs[i]);
                         document.Add(NewTextField(Random, "to", linkValue, Field.Store.NO));
                     }
                 }
@@ -791,8 +791,7 @@ namespace Lucene.Net.Tests.Join
                 while ((ord = docTermOrds.NextOrd()) != SortedSetDocValues.NO_MORE_ORDS)
                 {
                     docTermOrds.LookupOrd(ord, joinValue);
-                    var joinScore = JoinValueToJoinScores.ContainsKey(joinValue) ? JoinValueToJoinScores[joinValue] : null;
-                    if (joinScore == null)
+                    if (!JoinValueToJoinScores.TryGetValue(joinValue, out JoinScore joinScore) || joinScore == null)
                     {
                         JoinValueToJoinScores[BytesRef.DeepCopyOf(joinValue)] = joinScore = new JoinScore();
                     }
@@ -850,8 +849,7 @@ namespace Lucene.Net.Tests.Join
                     return;
                 }
 
-                var joinScore = JoinValueToJoinScores.ContainsKey(joinValue) ? JoinValueToJoinScores[joinValue] : null;
-                if (joinScore == null)
+                if (!JoinValueToJoinScores.TryGetValue(joinValue, out JoinScore joinScore) || joinScore == null)
                 {
                     JoinValueToJoinScores[BytesRef.DeepCopyOf(joinValue)] = joinScore = new JoinScore();
                 }
@@ -904,8 +902,7 @@ namespace Lucene.Net.Tests.Join
                 while ((ord = docTermOrds.NextOrd()) != SortedSetDocValues.NO_MORE_ORDS)
                 {
                     docTermOrds.LookupOrd(ord, scratch);
-                    JoinScore joinScore = _joinValueToJoinScores.ContainsKey(scratch) ? _joinValueToJoinScores[scratch] : null;
-                    if (joinScore == null)
+                    if (!_joinValueToJoinScores.TryGetValue(scratch, out JoinScore joinScore) || joinScore == null)
                     {
                         continue;
                     }
@@ -961,8 +958,7 @@ namespace Lucene.Net.Tests.Join
             public virtual void Collect(int doc)
             {
                 terms.Get(doc, spare);
-                JoinScore joinScore = JoinValueToJoinScores.ContainsKey(spare) ? JoinValueToJoinScores[spare] : null;
-                if (joinScore == null)
+                if (!JoinValueToJoinScores.TryGetValue(spare, out JoinScore joinScore) || joinScore == null)
                 {
                     return;
                 }
@@ -1046,8 +1042,7 @@ namespace Lucene.Net.Tests.Join
             }
 
             FixedBitSet expectedResult = new FixedBitSet(topLevelReader.MaxDoc);
-            IList<RandomDoc> matchingDocs = randomValueDocs.ContainsKey(queryValue) ? randomValueDocs[queryValue] : null;
-            if (matchingDocs == null)
+            if (!randomValueDocs.TryGetValue(queryValue, out IList<RandomDoc> matchingDocs) || matchingDocs == null)
             {
                 return new FixedBitSet(topLevelReader.MaxDoc);
             }
@@ -1056,8 +1051,7 @@ namespace Lucene.Net.Tests.Join
             {
                 foreach (string linkValue in matchingDoc.LinkValues)
                 {
-                    IList<RandomDoc> otherMatchingDocs = linkValueDocuments.ContainsKey(linkValue) ? linkValueDocuments[linkValue] : null;
-                    if (otherMatchingDocs == null)
+                    if (!linkValueDocuments.TryGetValue(linkValue, out IList<RandomDoc> otherMatchingDocs) || otherMatchingDocs == null)
                     {
                         continue;
                     }
diff --git a/src/Lucene.Net.Tests.Misc/Document/TestLazyDocument.cs b/src/Lucene.Net.Tests.Misc/Document/TestLazyDocument.cs
index 10b0bfe..9b67986 100644
--- a/src/Lucene.Net.Tests.Misc/Document/TestLazyDocument.cs
+++ b/src/Lucene.Net.Tests.Misc/Document/TestLazyDocument.cs
@@ -128,8 +128,8 @@ namespace Lucene.Net.Documents
                     }
                     else
                     {
-                        int count = fieldValueCounts.ContainsKey(f.Name) ?
-                          fieldValueCounts[f.Name] : 0;
+                        if (!fieldValueCounts.TryGetValue(f.Name, out int count))
+                            count = 0;
                         count++;
                         fieldValueCounts.Put(f.Name, count);
                         assertTrue(f.Name + " is " + f.GetType(),
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/AnalyzingSuggesterTest.cs b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/AnalyzingSuggesterTest.cs
index abac4aa..fe32ef8 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/AnalyzingSuggesterTest.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/AnalyzingSuggesterTest.cs
@@ -152,9 +152,9 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 string title = nextDoc.GetField("title").GetStringValue();
                 int randomWeight = Random.nextInt(100);
                 keys.Add(new Input(title, randomWeight));
-                if (!mapping.ContainsKey(title) || mapping[title] < randomWeight)
+                if (!mapping.TryGetValue(title, out long titleValue) || titleValue < randomWeight)
                 {
-                    mapping.Put(title, Convert.ToInt64(randomWeight));
+                    mapping[title] = Convert.ToInt64(randomWeight);
                 }
             }
             AnalyzingSuggester analyzingSuggester = new AnalyzingSuggester(new MockAnalyzer(Random), new MockAnalyzer(Random),
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs
index 1f7d7dd..9b0e852 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs
@@ -514,8 +514,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                             b.append(doc[j]);
                         }
                         string token = b.toString();
-                        int? curCount = model.ContainsKey(token) ? model[token] : null;
-                        if (curCount == null)
+                        if (!model.TryGetValue(token, out int? curCount) || curCount == null)
                         {
                             model.Put(token, 1);
                         }
@@ -525,7 +524,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         }
                         if (VERBOSE)
                         {
-                            Console.WriteLine("  add '" + token + "' -> count=" + (model.ContainsKey(token) ? model[token].ToString() : ""));
+                            Console.WriteLine("  add '" + token + "' -> count=" + (model.TryGetValue(token, out int? count) ? (count.HasValue ? count.ToString() : "null") : ""));
                         }
                     }
                 }
@@ -630,8 +629,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     {
                         //int? count = gramCounts.get(i - 1).get(context);
                         var gramCount = gramCounts[i - 1];
-                        int? count = gramCount.ContainsKey(context) ? gramCount[context] : null;
-                        if (count == null)
+                        if (!gramCount.TryGetValue(context, out int? count) || count == null)
                         {
                             // We never saw this context:
                             backoff *= FreeTextSuggester.ALPHA;
@@ -673,8 +671,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                             }
                             string ngram = (context + " " + term).Trim();
                             //Integer count = model.get(ngram);
-                            int? count = model.ContainsKey(ngram) ? model[ngram] : null;
-                            if (count != null)
+                            if (model.TryGetValue(ngram, out int? count) && count != null)
                             {
                                 // LUCENENET NOTE: We need to calculate this as decimal because when using double it can sometimes 
                                 // return numbers that are greater than long.MaxValue, which results in a negative long number.
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/DocumentDictionaryTest.cs b/src/Lucene.Net.Tests.Suggest/Suggest/DocumentDictionaryTest.cs
index c3b43fe..cac6615 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/DocumentDictionaryTest.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/DocumentDictionaryTest.cs
@@ -157,7 +157,7 @@ namespace Lucene.Net.Search.Suggest
             while ((f = inputIterator.Next()) != null)
             {
                 string field = f.Utf8ToString();
-                Document doc = docs.ContainsKey(field) ? docs[field] : null;
+                Document doc = docs[field];
                 docs.Remove(field);
                 //Document doc = docs.Remove(f.Utf8ToString());
                 assertTrue(f.equals(new BytesRef(doc.Get(FIELD_NAME))));
@@ -201,7 +201,7 @@ namespace Lucene.Net.Search.Suggest
             while ((f = inputIterator.Next()) != null)
             {
                 var field = f.Utf8ToString();
-                Document doc = docs.ContainsKey(field) ? docs[field] : null;
+                Document doc = docs[field];
                 docs.Remove(field);
                 assertTrue(f.equals(new BytesRef(doc.Get(FIELD_NAME))));
                 IIndexableField weightField = doc.GetField(WEIGHT_FIELD_NAME);
@@ -246,7 +246,7 @@ namespace Lucene.Net.Search.Suggest
             while ((f = inputIterator.Next()) != null)
             {
                 string field = f.Utf8ToString();
-                Document doc = docs.ContainsKey(field) ? docs[field] : null;
+                Document doc = docs[field];
                 docs.Remove(field);
                 //Document doc = docs.remove(f.utf8ToString());
                 assertTrue(f.equals(new BytesRef(doc.Get(FIELD_NAME))));
@@ -325,7 +325,7 @@ namespace Lucene.Net.Search.Suggest
             while ((f = inputIterator.Next()) != null)
             {
                 var field = f.Utf8ToString();
-                Document doc = docs.ContainsKey(field) ? docs[field] : null;
+                Document doc = docs[field];
                 docs.Remove(field);
                 assertTrue(f.equals(new BytesRef(doc.Get(FIELD_NAME))));
                 IIndexableField weightField = doc.GetField(WEIGHT_FIELD_NAME);
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/DocumentValueSourceDictionaryTest.cs b/src/Lucene.Net.Tests.Suggest/Suggest/DocumentValueSourceDictionaryTest.cs
index 484e3ae..86866c7 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/DocumentValueSourceDictionaryTest.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/DocumentValueSourceDictionaryTest.cs
@@ -116,7 +116,7 @@ namespace Lucene.Net.Search.Suggest
             while ((f = inputIterator.Next()) != null)
             {
                 string field = f.Utf8ToString();
-                Document doc = docs.ContainsKey(field) ? docs[field] : null;
+                Document doc = docs[field];
                 docs.Remove(field);
                 //Document doc = docs.remove(f.utf8ToString());
                 long w1 = doc.GetField(WEIGHT_FIELD_NAME_1).GetInt64ValueOrDefault();
@@ -154,7 +154,7 @@ namespace Lucene.Net.Search.Suggest
             while ((f = inputIterator.Next()) != null)
             {
                 string field = f.Utf8ToString();
-                Document doc = docs.ContainsKey(field) ? docs[field] : null;
+                Document doc = docs[field];
                 docs.Remove(field);
                 long w1 = doc.GetField(WEIGHT_FIELD_NAME_1).GetInt64ValueOrDefault();
                 long w2 = doc.GetField(WEIGHT_FIELD_NAME_2).GetInt64ValueOrDefault();
@@ -197,7 +197,7 @@ namespace Lucene.Net.Search.Suggest
             while ((f = inputIterator.Next()) != null)
             {
                 string field = f.Utf8ToString();
-                Document doc = docs.ContainsKey(field) ? docs[field] : null;
+                Document doc = docs[field];
                 docs.Remove(field);
                 long w1 = doc.GetField(WEIGHT_FIELD_NAME_1).GetInt64ValueOrDefault();
                 long w2 = doc.GetField(WEIGHT_FIELD_NAME_2).GetInt64ValueOrDefault();
@@ -262,7 +262,7 @@ namespace Lucene.Net.Search.Suggest
             while ((f = inputIterator.Next()) != null)
             {
                 string field = f.Utf8ToString();
-                Document doc = docs.ContainsKey(field) ? docs[field] : null;
+                Document doc = docs[field];
                 docs.Remove(field);
                 long w1 = doc.GetField(WEIGHT_FIELD_NAME_1).GetInt64ValueOrDefault();
                 long w2 = doc.GetField(WEIGHT_FIELD_NAME_2).GetInt64ValueOrDefault();
@@ -298,7 +298,7 @@ namespace Lucene.Net.Search.Suggest
             while ((f = inputIterator.Next()) != null)
             {
                 string field = f.Utf8ToString();
-                Document doc = docs.ContainsKey(field) ? docs[field] : null;
+                Document doc = docs[field];
                 docs.Remove(field);
                 assertTrue(f.equals(new BytesRef(doc.Get(FIELD_NAME))));
                 assertEquals(inputIterator.Weight, 10);
diff --git a/src/Lucene.Net.Tests/Index/TestMultiFields.cs b/src/Lucene.Net.Tests/Index/TestMultiFields.cs
index aecb631..79f2a95 100644
--- a/src/Lucene.Net.Tests/Index/TestMultiFields.cs
+++ b/src/Lucene.Net.Tests/Index/TestMultiFields.cs
@@ -79,11 +79,11 @@ namespace Lucene.Net.Index
                     {
                         string s = TestUtil.RandomUnicodeString(Random, 10);
                         BytesRef term = new BytesRef(s);
-                        if (!docs.ContainsKey(term))
+                        if (!docs.TryGetValue(term, out IList<int?> docsTerm))
                         {
-                            docs[term] = new List<int?>();
+                            docs[term] = docsTerm = new List<int?>();
                         }
-                        docs[term].Add(i);
+                        docsTerm.Add(i);
                         terms.Add(term);
                         uniqueTerms.Add(term);
                         f.SetStringValue(s);
diff --git a/src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs b/src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs
index 26187dc..982eed2 100644
--- a/src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs
+++ b/src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs
@@ -297,16 +297,15 @@ namespace Lucene.Net.Index
                     int tokenOffset = Random.Next(5);
 
                     Token token = MakeToken(text, posIncr, offset + offIncr, offset + offIncr + tokenOffset);
-                    if (!actualTokens.ContainsKey(text))
+                    if (!actualTokens.TryGetValue(text, out IDictionary<int?, IList<Token>> postingsByDoc))
                     {
-                        actualTokens[text] = new Dictionary<int?, IList<Token>>();
+                        actualTokens[text] = postingsByDoc = new Dictionary<int?, IList<Token>>();
                     }
-                    IDictionary<int?, IList<Token>> postingsByDoc = actualTokens[text];
-                    if (!postingsByDoc.ContainsKey(docCount))
+                    if (!postingsByDoc.TryGetValue(docCount, out IList<Token> postings))
                     {
-                        postingsByDoc[docCount] = new List<Token>();
+                        postingsByDoc[docCount] = postings = new List<Token>();
                     }
-                    postingsByDoc[docCount].Add(token);
+                    postings.Add(token);
                     tokens.Add(token);
                     pos += posIncr;
                     // stuff abs position into type:
diff --git a/src/Lucene.Net.Tests/Search/TestCustomSearcherSort.cs b/src/Lucene.Net.Tests/Search/TestCustomSearcherSort.cs
index 1676be5..ebb5f9c 100644
--- a/src/Lucene.Net.Tests/Search/TestCustomSearcherSort.cs
+++ b/src/Lucene.Net.Tests/Search/TestCustomSearcherSort.cs
@@ -180,13 +180,13 @@ namespace Lucene.Net.Search
                     int? luceneId = null;
 
                     luceneId = Convert.ToInt32(hits[docnum].Doc);
-                    if (idMap.ContainsKey(luceneId))
+                    if (idMap.TryGetValue(luceneId, out int? value))
                     {
                         StringBuilder message = new StringBuilder(prefix);
                         message.Append("Duplicate key for hit index = ");
                         message.Append(docnum);
                         message.Append(", previous index = ");
-                        message.Append((idMap[luceneId]).ToString());
+                        message.Append(value.ToString());
                         message.Append(", Lucene ID = ");
                         message.Append(luceneId);
                         Log(message.ToString());
diff --git a/src/Lucene.Net/Codecs/PerField/PerFieldDocValuesFormat.cs b/src/Lucene.Net/Codecs/PerField/PerFieldDocValuesFormat.cs
index 5b9cc74..e66d972 100644
--- a/src/Lucene.Net/Codecs/PerField/PerFieldDocValuesFormat.cs
+++ b/src/Lucene.Net/Codecs/PerField/PerFieldDocValuesFormat.cs
@@ -266,11 +266,12 @@ namespace Lucene.Net.Codecs.PerField
                                 Debug.Assert(suffix != null);
                                 DocValuesFormat format = DocValuesFormat.ForName(formatName);
                                 string segmentSuffix = GetFullSegmentSuffix(readState.SegmentSuffix, GetSuffix(formatName, suffix));
-                                if (!formats.ContainsKey(segmentSuffix))
+                                // LUCENENET: Eliminated extra lookup by using TryGetValue instead of ContainsKey
+                                if (!formats.TryGetValue(segmentSuffix, out DocValuesProducer field))
                                 {
-                                    formats[segmentSuffix] = format.FieldsProducer(new SegmentReadState(readState, segmentSuffix));
+                                    formats[segmentSuffix] = field = format.FieldsProducer(new SegmentReadState(readState, segmentSuffix));
                                 }
-                                fields[fieldName] = formats[segmentSuffix];
+                                fields[fieldName] = field;
                             }
                         }
                     }
diff --git a/src/Lucene.Net/Codecs/PerField/PerFieldPostingsFormat.cs b/src/Lucene.Net/Codecs/PerField/PerFieldPostingsFormat.cs
index 0b0be1a..2bf9307 100644
--- a/src/Lucene.Net/Codecs/PerField/PerFieldPostingsFormat.cs
+++ b/src/Lucene.Net/Codecs/PerField/PerFieldPostingsFormat.cs
@@ -220,11 +220,12 @@ namespace Lucene.Net.Codecs.PerField
                                 Debug.Assert(suffix != null);
                                 PostingsFormat format = PostingsFormat.ForName(formatName);
                                 string segmentSuffix = GetSuffix(formatName, suffix);
-                                if (!formats.ContainsKey(segmentSuffix))
+                                // LUCENENET: Eliminated extra lookup by using TryGetValue instead of ContainsKey
+                                if (!formats.TryGetValue(segmentSuffix, out Codecs.FieldsProducer field))
                                 {
-                                    formats[segmentSuffix] = format.FieldsProducer(new SegmentReadState(readState, segmentSuffix));
+                                    formats[segmentSuffix] = field = format.FieldsProducer(new SegmentReadState(readState, segmentSuffix));
                                 }
-                                fields[fieldName] = formats[segmentSuffix];
+                                fields[fieldName] = field;
                             }
                         }
                     }
diff --git a/src/Lucene.Net/Index/IndexFileDeleter.cs b/src/Lucene.Net/Index/IndexFileDeleter.cs
index 3f1eb20..504983d 100644
--- a/src/Lucene.Net/Index/IndexFileDeleter.cs
+++ b/src/Lucene.Net/Index/IndexFileDeleter.cs
@@ -658,29 +658,19 @@ namespace Lucene.Net.Index
         public bool Exists(string fileName)
         {
             Debug.Assert(IsLocked);
-            if (!refCounts.ContainsKey(fileName))
-            {
-                return false;
-            }
-            else
-            {
-                return GetRefCount(fileName).count > 0;
-            }
+            // LUCENENET: Using TryGetValue to eliminate extra lookup
+            return refCounts.TryGetValue(fileName, out RefCount value) ? value.count > 0 : false;
         }
 
         private RefCount GetRefCount(string fileName)
         {
             Debug.Assert(IsLocked);
-            RefCount rc;
-            if (!refCounts.ContainsKey(fileName))
+            // LUCENENET: Using TryGetValue to eliminate extra lookup
+            if (!refCounts.TryGetValue(fileName, out RefCount rc))
             {
                 rc = new RefCount(fileName);
                 refCounts[fileName] = rc;
             }
-            else
-            {
-                rc = refCounts[fileName];
-            }
             return rc;
         }
 
@@ -708,7 +698,10 @@ namespace Lucene.Net.Index
                 // of unref'd files, and then you add new docs / do
                 // merging, and it reuses that segment name.
                 // TestCrash.testCrashAfterReopen can hit this:
-                if (!refCounts.ContainsKey(fileName) || refCounts[fileName].count == 0)
+
+                // LUCENENET: Using TryGetValue to eliminate extra lookup
+                bool got = refCounts.TryGetValue(fileName, out RefCount refCount);
+                if (!got || got && refCount.count == 0)
                 {
                     if (infoStream.IsEnabled("IFD"))
                     {
diff --git a/src/Lucene.Net/Index/IndexWriter.cs b/src/Lucene.Net/Index/IndexWriter.cs
index e4f8847..b422691 100644
--- a/src/Lucene.Net/Index/IndexWriter.cs
+++ b/src/Lucene.Net/Index/IndexWriter.cs
@@ -3338,12 +3338,8 @@ namespace Lucene.Net.Index
             // just want to update the DS name of this SegmentInfo.
             string dsName = Lucene3xSegmentInfoFormat.GetDocStoreSegment(info.Info);
             Debug.Assert(dsName != null);
-            string newDsName;
-            if (dsNames.ContainsKey(dsName))
-            {
-                newDsName = dsNames[dsName];
-            }
-            else
+            // LUCENENET: Eliminated extra lookup by using TryGetValue instead of ContainsKey
+            if (!dsNames.TryGetValue(dsName, out string newDsName))
             {
                 dsNames[dsName] = segName;
                 newDsName = segName;
diff --git a/src/Lucene.Net/Util/FieldCacheSanityChecker.cs b/src/Lucene.Net/Util/FieldCacheSanityChecker.cs
index c0bd042..eac78a4 100644
--- a/src/Lucene.Net/Util/FieldCacheSanityChecker.cs
+++ b/src/Lucene.Net/Util/FieldCacheSanityChecker.cs
@@ -232,12 +232,13 @@ namespace Lucene.Net.Util
                 {
                     ReaderField kid = new ReaderField(kidKey, rf.FieldName);
 
-                    if (badChildren.ContainsKey(kid))
+                    // LUCENENET: Eliminated extra lookup by using TryGetValue instead of ContainsKey
+                    if (badChildren.TryGetValue(kid, out ISet<ReaderField> badKid))
                     {
                         // we've already process this kid as RF and found other problems
                         // track those problems as our own
                         badKids.Put(rf, kid);
-                        badKids.PutAll(rf, badChildren[kid]);
+                        badKids.PutAll(rf, badKid);
                         badChildren.Remove(kid);
                     }
                     else if (rfToValIdSets.ContainsKey(kid))
diff --git a/src/Lucene.Net/Util/MapOfSets.cs b/src/Lucene.Net/Util/MapOfSets.cs
index b8e83e4..5859e9c 100644
--- a/src/Lucene.Net/Util/MapOfSets.cs
+++ b/src/Lucene.Net/Util/MapOfSets.cs
@@ -50,15 +50,10 @@ namespace Lucene.Net.Util
         /// <returns> The size of the <see cref="ISet{T}"/> associated with key once val is added to it. </returns>
         public virtual int Put(TKey key, TValue val)
         {
-            ISet<TValue> theSet;
-            if (theMap.ContainsKey(key))
+            // LUCENENET: Eliminated extra lookup by using TryGetValue instead of ContainsKey
+            if (!theMap.TryGetValue(key, out ISet<TValue> theSet))
             {
-                theSet = theMap[key];
-            }
-            else
-            {
-                theSet = new HashSet<TValue>();
-                theMap[key] = theSet;
+                theMap[key] = theSet = new HashSet<TValue>();
             }
             theSet.Add(val);
             return theSet.Count;
@@ -71,15 +66,10 @@ namespace Lucene.Net.Util
         /// <returns> The size of the <see cref="ISet{T}"/> associated with key once val is added to it. </returns>
         public virtual int PutAll(TKey key, IEnumerable<TValue> vals)
         {
-            ISet<TValue> theSet;
-            if (theMap.ContainsKey(key))
-            {
-                theSet = theMap[key];
-            }
-            else
+            // LUCENENET: Eliminated extra lookup by using TryGetValue instead of ContainsKey
+            if (!theMap.TryGetValue(key, out ISet<TValue> theSet))
             {
-                theSet = new HashSet<TValue>();
-                theMap[key] = theSet;
+                theMap[key] = theSet = new HashSet<TValue>();
             }
             theSet.UnionWith(vals);
             return theSet.Count;


Mime
View raw message