Fix documentation xref links and most docfx build warnings, #969

src/Lucene.Net.Analysis.Common/Analysis/Compound/DictionaryCompoundWordTokenFilter.cs

@@ -46,9 +46,7 @@ public class DictionaryCompoundWordTokenFilter : CompoundWordTokenFilterBase
         /// </summary>
         /// <param name="matchVersion">
         ///          Lucene version to enable correct Unicode 4.0 behavior in the
-        ///          dictionaries if Version > 3.0. See <a
-        ///          href="CompoundWordTokenFilterBase.html#version"
-        ///          >CompoundWordTokenFilterBase</a> for details. </param>
+        ///          dictionaries if Version > 3.0. See <see cref="CompoundWordTokenFilterBase"/> for details. </param>
         /// <param name="input">
         ///          the <see cref="TokenStream"/> to process </param>
         /// <param name="dictionary">
@@ -67,9 +65,7 @@ public DictionaryCompoundWordTokenFilter(LuceneVersion matchVersion, TokenStream
         /// </summary>
         /// <param name="matchVersion">
         ///          Lucene version to enable correct Unicode 4.0 behavior in the
-        ///          dictionaries if Version > 3.0. See <a
-        ///          href="CompoundWordTokenFilterBase.html#version"
-        ///          >CompoundWordTokenFilterBase</a> for details. </param>
+        ///          dictionaries if Version > 3.0. See <see cref="CompoundWordTokenFilterBase"/> for details. </param>
         /// <param name="input">
         ///          the <see cref="TokenStream"/> to process </param>
         /// <param name="dictionary">

src/Lucene.Net.Analysis.Common/Analysis/Compound/HyphenationCompoundWordTokenFilter.cs

@@ -50,9 +50,7 @@ public class HyphenationCompoundWordTokenFilter : CompoundWordTokenFilterBase
         /// </summary>
         /// <param name="matchVersion">
         ///          Lucene version to enable correct Unicode 4.0 behavior in the
-        ///          dictionaries if Version > 3.0. See <a
-        ///          href="CompoundWordTokenFilterBase.html#version"
-        ///          >CompoundWordTokenFilterBase</a> for details. </param>
+        ///          dictionaries if Version > 3.0. See <see cref="CompoundWordTokenFilterBase"/> for details. </param>
         /// <param name="input">
         ///          the <see cref="TokenStream"/> to process </param>
         /// <param name="hyphenator">
@@ -71,9 +69,7 @@ public HyphenationCompoundWordTokenFilter(LuceneVersion matchVersion, TokenStrea
         /// </summary>
         /// <param name="matchVersion">
         ///          Lucene version to enable correct Unicode 4.0 behavior in the
-        ///          dictionaries if Version > 3.0. See <a
-        ///          href="CompoundWordTokenFilterBase.html#version"
-        ///          >CompoundWordTokenFilterBase</a> for details. </param>
+        ///          dictionaries if Version > 3.0. See <see cref="CompoundWordTokenFilterBase"/> for details. </param>
         /// <param name="input">
         ///          the <see cref="TokenStream"/> to process </param>
         /// <param name="hyphenator">

src/Lucene.Net.Analysis.Common/Analysis/Core/TypeTokenFilter.cs

@@ -76,7 +76,7 @@ public TypeTokenFilter(LuceneVersion version, TokenStream input, ICollection<str
 
         /// <summary>
         /// By default accept the token if its type is not a stop type.
-        /// When the <see cref="useWhiteList"/> parameter is set to true then accept the token if its type is contained in the <see cref="stopTypes"/>
+        /// When the <c>useWhiteList</c> parameter is set to true then accept the token if its type is contained in the <c>stopTypes</c>
         /// </summary>
         protected override bool Accept()
         {

src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/LimitTokenCountFilterFactory.cs

@@ -32,7 +32,7 @@ namespace Lucene.Net.Analysis.Miscellaneous
     ///   </analyzer>
     /// &lt;/fieldType&gt;</code>
     /// <para>
-    /// The <see cref="consumeAllTokens"/> property is optional and defaults to <c>false</c>.
+    /// The <see cref="CONSUME_ALL_TOKENS_KEY"/> property is optional and defaults to <c>false</c>.
     /// See <see cref="LimitTokenCountFilter"/> for an explanation of it's use.
     /// </para>
     /// </summary>

src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/LimitTokenPositionFilterFactory.cs

@@ -32,7 +32,7 @@ namespace Lucene.Net.Analysis.Miscellaneous
     ///   </analyzer>
     /// &lt;/fieldType&gt;</code>
     /// <para>
-    /// The <see cref="consumeAllTokens"/> property is optional and defaults to <c>false</c>.
+    /// The <see cref="CONSUME_ALL_TOKENS_KEY"/> property is optional and defaults to <c>false</c>.
     /// See <see cref="LimitTokenPositionFilter"/> for an explanation of its use.
     /// </para>
     /// </summary>

src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/StemmerOverrideFilter.cs

@@ -166,7 +166,7 @@ public class Builder
             private readonly CharsRef charsSpare = new CharsRef();
 
             /// <summary>
-            /// Creates a new <see cref="Builder"/> with <see cref="ignoreCase"/> set to <c>false</c>
+            /// Creates a new <see cref="Builder"/> with <c>ignoreCase</c> set to <c>false</c>
             /// </summary>
             public Builder()
                 : this(false)

src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs

@@ -62,7 +62,7 @@ namespace Lucene.Net.Analysis.Pattern
     /// </code>
     /// </para>
     /// <para>
-    /// plus if <see cref="preserveOriginal"/> is true, it would also return
+    /// plus if <c>preserveOriginal</c> is true, it would also return
     /// <c>camelCaseFilter</c>
     /// </para>
     /// </summary>

src/Lucene.Net.Analysis.Common/Analysis/Reverse/ReverseStringFilter.cs

@@ -25,7 +25,7 @@ namespace Lucene.Net.Analysis.Reverse
     /// <summary>
     /// Reverse token string, for example "country" => "yrtnuoc".
     /// <para>
-    /// If <see cref="marker"/> is supplied, then tokens will be also prepended by
+    /// If <c>marker</c> is supplied, then tokens will be also prepended by
     /// that character. For example, with a marker of &#x5C;u0001, "country" =>
     /// "&#x5C;u0001yrtnuoc". This is useful when implementing efficient leading
     /// wildcards search.

src/Lucene.Net.Analysis.Common/Analysis/Util/BufferedCharFilter.cs

@@ -220,7 +220,7 @@ private void EnsureOpen()
         /// Sets a mark position in this reader. The parameter <paramref name="markLimit"/>
         /// indicates how many characters can be read before the mark is invalidated.
         /// Calling <see cref="Reset()"/> will reposition the reader back to the marked
-        /// position if <see cref="markLimit"/> has not been surpassed.
+        /// position if <c>markLimit</c> has not been surpassed.
         /// </summary>
         /// <param name="markLimit">
         /// the number of characters that can be read before the mark is
@@ -555,7 +555,7 @@ public override void Reset()
         /// <summary>
         /// Skips <paramref name="amount"/> characters in this reader. Subsequent
         /// <see cref="Read()"/>s will not return these characters unless <see cref="Reset()"/>
-        /// is used. Skipping characters may invalidate a mark if <see cref="markLimit"/>
+        /// is used. Skipping characters may invalidate a mark if <c>markLimit</c>
         /// is surpassed.
         /// </summary>
         /// <param name="amount">the maximum number of characters to skip.</param>

src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs

@@ -1422,7 +1422,7 @@ private void SetImpl(char[] text, int startIndex, int length, MapValue value)
 
         /// <summary>
         /// This implementation enumerates over the specified <see cref="T:IDictionary{char[],TValue}"/>'s
-        /// entries, and calls this dictionary's <see cref="Set(char[], TValue?)"/> operation once for each entry.
+        /// entries, and calls this dictionary's <c>Set(char[], TValue)</c> operation once for each entry.
         /// <para/>
         /// If ignoreCase is <c>true</c> for this dictionary, the text arrays will be directly modified.
         /// The user should never modify the text arrays after calling this method.
@@ -1448,7 +1448,7 @@ public virtual void PutAll(IDictionary<char[], TValue> collection)
 
         /// <summary>
         /// This implementation enumerates over the specified <see cref="T:IDictionary{string,TValue}"/>'s
-        /// entries, and calls this dictionary's <see cref="Set(string, TValue?)"/> operation once for each entry.
+        /// entries, and calls this dictionary's <c>Set(string, TValue)</c> operation once for each entry.
         /// </summary>
         /// <param name="collection">A dictionary of values to add/update in the current dictionary.</param>
         /// <exception cref="ArgumentNullException">
@@ -1471,7 +1471,7 @@ public virtual void PutAll(IDictionary<string, TValue> collection)
 
         /// <summary>
         /// This implementation enumerates over the specified <see cref="T:IDictionary{ICharSequence,TValue}"/>'s
-        /// entries, and calls this dictionary's <see cref="Set(ICharSequence, TValue?)"/> operation once for each entry.
+        /// entries, and calls this dictionary's <c>Set(ICharSequence, TValue)</c> operation once for each entry.
         /// </summary>
         /// <param name="collection">A dictionary of values to add/update in the current dictionary.</param>
         /// <exception cref="ArgumentNullException">
@@ -1498,7 +1498,7 @@ public virtual void PutAll(IDictionary<ICharSequence, TValue> collection)
 
         /// <summary>
         /// This implementation enumerates over the specified <see cref="T:IDictionary{T,TValue}"/>'s
-        /// entries, and calls this dictionary's <see cref="Set{T}(T, TValue?)"/> operation once for each entry.
+        /// entries, and calls this dictionary's <c>Set(T, TValue)</c> operation once for each entry.
         /// </summary>
         /// <param name="collection">A dictionary of values to add/update in the current dictionary.</param>
         /// <exception cref="ArgumentNullException">
@@ -1521,7 +1521,7 @@ public virtual void PutAll<T>(IDictionary<T, TValue> collection)
 
         /// <summary>
         /// This implementation enumerates over the specified <see cref="T:IEnumerable{KeyValuePair{char[],TValue}}"/>'s
-        /// entries, and calls this dictionary's <see cref="Set(char[], TValue?)"/> operation once for each entry.
+        /// entries, and calls this dictionary's <c>Set(char[], TValue)</c> operation once for each entry.
         /// </summary>
         /// <param name="collection">The values to add/update in the current dictionary.</param>
         /// <exception cref="ArgumentNullException">
@@ -1544,7 +1544,7 @@ public virtual void PutAll(IEnumerable<KeyValuePair<char[], TValue>> collection)
 
         /// <summary>
         /// This implementation enumerates over the specified <see cref="T:IEnumerable{KeyValuePair{string,TValue}}"/>'s
-        /// entries, and calls this dictionary's <see cref="Set(string, TValue)"/> operation once for each entry.
+        /// entries, and calls this dictionary's <c>Set(string, TValue)</c> operation once for each entry.
         /// </summary>
         /// <param name="collection">The values to add/update in the current dictionary.</param>
         /// <exception cref="ArgumentNullException">
@@ -1567,7 +1567,7 @@ public virtual void PutAll(IEnumerable<KeyValuePair<string, TValue>> collection)
 
         /// <summary>
         /// This implementation enumerates over the specified <see cref="T:IEnumerable{KeyValuePair{ICharSequence,TValue}}"/>'s
-        /// entries, and calls this dictionary's <see cref="Set(ICharSequence, TValue)"/> operation once for each entry.
+        /// entries, and calls this dictionary's <c>Set(ICharSequence, TValue)</c> operation once for each entry.
         /// </summary>
         /// <param name="collection">The values to add/update in the current dictionary.</param>
         /// <exception cref="ArgumentNullException">
@@ -1594,7 +1594,7 @@ public virtual void PutAll(IEnumerable<KeyValuePair<ICharSequence, TValue>> coll
 
         /// <summary>
         /// This implementation enumerates over the specified <see cref="T:IEnumerable{KeyValuePair{TKey,TValue}}"/>'s
-        /// entries, and calls this dictionary's <see cref="Set{T}(T, TValue?)"/> operation once for each entry.
+        /// entries, and calls this dictionary's <c>Set(T, TValue)</c> operation once for each entry.
         /// </summary>
         /// <param name="collection">The values to add/update in the current dictionary.</param>
         /// <exception cref="ArgumentNullException">
@@ -2024,8 +2024,8 @@ public virtual CharArrayDictionary<TValue> ToCharArrayDictionary()
         /// using the specified <paramref name="matchVersion"/> value. Preserves the value of <c>ignoreCase</c> from the current instance.
         /// </summary>
         /// <param name="matchVersion">
-        ///          compatibility match version see <a href="#version">Version
-        ///          note</a> above for details. </param>
+        ///          compatibility match version see Version
+        ///          note above for details. </param>
         /// <returns> A copy of the current <see cref="CharArrayDictionary{TValue}"/> as a <see cref="CharArrayDictionary{TValue}"/>. </returns>
         // LUCENENET specific - allow .NET-like syntax for copying CharArrayDictionary
         public virtual CharArrayDictionary<TValue> ToCharArrayDictionary(LuceneVersion matchVersion)
@@ -2038,8 +2038,8 @@ public virtual CharArrayDictionary<TValue> ToCharArrayDictionary(LuceneVersion m
         /// using the specified <paramref name="matchVersion"/> and <paramref name="ignoreCase"/> values.
         /// </summary>
         /// <param name="matchVersion">
-        ///          compatibility match version see <a href="#version">Version
-        ///          note</a> above for details. </param>
+        ///          compatibility match version see Version
+        ///          note above for details. </param>
         /// <param name="ignoreCase"><c>false</c> if and only if the set should be case sensitive otherwise <c>true</c>.</param>
         /// <returns> A copy of the current <see cref="CharArrayDictionary{TValue}"/> as a <see cref="CharArrayDictionary{TValue}"/>. </returns>
         // LUCENENET specific - allow .NET-like syntax for copying CharArrayDictionary
@@ -3311,8 +3311,8 @@ public static class CharArrayDictionary // LUCENENET specific: CA1052 Static hol
         /// </para>
         /// </summary>
         /// <param name="matchVersion">
-        ///          compatibility match version see <a href="#version">Version
-        ///          note</a> above for details. This argument will be ignored if the
+        ///          compatibility match version see Version
+        ///          note above for details. This argument will be ignored if the
         ///          given dictionary is a <see cref="CharArrayDictionary{TValue}"/>. </param>
         /// <param name="dictionary">
         ///          a dictionary to copy </param>
@@ -3859,8 +3859,8 @@ public static class DictionaryExtensions
         /// <param name="dictionary">
         ///          A <see cref="IDictionary{TKey, TValue}"/> to copy. </param>
         /// <param name="matchVersion">
-        ///          compatibility match version see <a href="#version">Version
-        ///          note</a> above for details. </param>
+        ///          compatibility match version see Version
+        ///          note above for details. </param>
         /// <returns> A copy of the current dictionary as a <see cref="CharArrayDictionary{TValue}"/>. </returns>
         /// <exception cref="ArgumentNullException"><paramref name="dictionary"/> is <c>null</c>.</exception>
         public static CharArrayDictionary<TValue> ToCharArrayDictionary<TValue>(this IDictionary<string, TValue> dictionary, LuceneVersion matchVersion)
@@ -3879,8 +3879,8 @@ public static CharArrayDictionary<TValue> ToCharArrayDictionary<TValue>(this IDi
         /// <param name="dictionary">
         ///          A <see cref="IDictionary{TKey, TValue}"/> to copy. </param>
         /// <param name="matchVersion">
-        ///          compatibility match version see <a href="#version">Version
-        ///          note</a> above for details. </param>
+        ///          compatibility match version see Version
+        ///          note above for details. </param>
         /// <param name="ignoreCase"><c>false</c> if and only if the set should be case sensitive otherwise <c>true</c>.</param>
         /// <returns> A copy of the current dictionary as a <see cref="CharArrayDictionary{TValue}"/>. </returns>
         /// <exception cref="ArgumentNullException"><paramref name="dictionary"/> is <c>null</c>.</exception>

src/Lucene.Net.Analysis.Common/Analysis/Util/FilteringTokenFilter.cs

@@ -54,7 +54,7 @@ private static void CheckPositionIncrement(LuceneVersion version, bool enablePos
 
         /// <summary>
         /// Create a new <see cref="FilteringTokenFilter"/>. </summary>
-        /// <param name="version">                  the <a href="#lucene_match_version">Lucene match version</a> </param>
+        /// <param name="version">                  the Lucene match version </param>
         /// <param name="enablePositionIncrements"> whether to increment position increments when filtering out terms </param>
         /// <param name="input">                    the input to consume </param>
         /// @deprecated enablePositionIncrements=false is not supported anymore as of Lucene 4.4

src/Lucene.Net.Analysis.Common/Collation/package.md

@@ -121,7 +121,7 @@ assertEquals("The index Term should be included.", 1, result.Length);
 
  __WARNING:__ Make sure you use exactly the same collator (`System.Globalization.CompareInfo` *and* `System.Globalization.CompareOptions`) at index and query time -- `System.Globalization.SortKey`s are only comparable when produced by the same collator. Since the platform collator is not independently versioned, it is unsafe to search against stored `System.Globalization.SortKey`s unless the following are exactly the same (best practice is to store this information with the index and check that they remain the same at query time):
 
-1.  The .NET runtime version, and the active globalization backend. .NET Framework uses Windows NLS, while .NET 5+ uses ICU by default; the two produce different sort keys and orderings. You can detect the active backend at runtime via <xref:Lucene.Net.Collation.CollationUtil.IsICU> (or its inverse, <xref:Lucene.Net.Collation.CollationUtil.IsNLS>) and store that value with the index to verify it matches at query time.
+1.  The .NET runtime version, and the active globalization backend. .NET Framework uses Windows NLS, while .NET 5+ uses ICU by default; the two produce different sort keys and orderings. You can detect the active backend at runtime (see [Globalization and ICU](https://learn.microsoft.com/en-us/dotnet/core/extensions/globalization-icu)) and store that value with the index to verify it matches at query time.
 
 2.  The language (and country and variant, if specified) of the culture used when obtaining the collator via `System.Globalization.CompareInfo.GetCompareInfo`.
 

src/Lucene.Net.Analysis.ICU/Collation/ICUCollationKeyAnalyzer.cs

@@ -32,7 +32,7 @@ namespace Lucene.Net.Collation
     /// <remarks>
     /// Converts the token into its <see cref="CollationKey"/>, and
     /// then encodes the <see cref="CollationKey"/> either directly or with
-    /// <see cref="IndexableBinaryStringTools"/> (see <a href="#version">below</a>), to allow it to
+    /// <see cref="IndexableBinaryStringTools"/> (see below), to allow it to
     /// be stored as an index term.
     /// <para/>
     /// <strong>WARNING:</strong> Make sure you use exactly the same <see cref="Collator"/> at

src/Lucene.Net.Analysis.ICU/overview.md

@@ -56,7 +56,7 @@ For an introduction to Lucene's analysis API, see the <xref:Lucene.Net.Analysis>
 *   [Search Term Folding](#search-term-folding): Removes distinctions
   (such as accent marks) between similar characters for a loose or fuzzy search.
 
-*   [Text Transformation](#text-transform): Transforms Unicode text in
+*   [Text Transformation](#text-transformation): Transforms Unicode text in
   a context-sensitive fashion: e.g. mapping Traditional to Simplified Chinese
 
 * * *

src/Lucene.Net.Analysis.Phonetic/Language/DoubleMetaphone.cs

@@ -27,7 +27,7 @@ namespace Lucene.Net.Analysis.Phonetic.Language
     /// Encodes a string into a double metaphone value. This Implementation is based on the algorithm by <c>Lawrence
     /// Philips</c>.
     /// <para/>
-    /// This class is conditionally thread-safe. The instance field <see cref="maxCodeLen"/> is mutable
+    /// This class is conditionally thread-safe. The instance field <see cref="MaxCodeLen"/> is mutable
     /// <see cref="MaxCodeLen"/> but is not volatile, and accesses are not synchronized. If an instance of the class is
     /// shared between threads, the caller needs to ensure that suitable synchronization is used to ensure safe publication
     /// of the value between threads, and must not set <see cref="MaxCodeLen"/> after initial setup.