lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [06/48] lucenenet git commit: Lucene.Net.Search: Fixed up documentation comments
Date Tue, 06 Jun 2017 00:11:39 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs b/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs
index 0b3401e..d172657 100644
--- a/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs
+++ b/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs
@@ -31,17 +31,17 @@ namespace Lucene.Net.Search
     using TermsEnum = Lucene.Net.Index.TermsEnum;
 
     /// <summary>
-    /// A wrapper for <seealso cref="MultiTermQuery"/>, that exposes its
-    /// functionality as a <seealso cref="Filter"/>.
-    /// <P>
-    /// <code>MultiTermQueryWrapperFilter</code> is not designed to
-    /// be used by itself. Normally you subclass it to provide a Filter
-    /// counterpart for a <seealso cref="MultiTermQuery"/> subclass.
-    /// <P>
-    /// For example, <seealso cref="TermRangeFilter"/> and <seealso cref="PrefixFilter"/> extend
-    /// <code>MultiTermQueryWrapperFilter</code>.
-    /// this class also provides the functionality behind
-    /// <seealso cref="MultiTermQuery#CONSTANT_SCORE_FILTER_REWRITE"/>;
+    /// A wrapper for <see cref="MultiTermQuery"/>, that exposes its
+    /// functionality as a <see cref="Filter"/>.
+    /// <para/>
+    /// <see cref="MultiTermQueryWrapperFilter{Q}"/> is not designed to
+    /// be used by itself. Normally you subclass it to provide a <see cref="Filter"/>
+    /// counterpart for a <see cref="MultiTermQuery"/> subclass.
+    /// <para/>
+    /// For example, <see cref="TermRangeFilter"/> and <see cref="PrefixFilter"/> extend
+    /// <see cref="MultiTermQueryWrapperFilter{Q}"/>.
+    /// This class also provides the functionality behind
+    /// <see cref="MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE"/>;
     /// this is why it is not abstract.
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -52,7 +52,7 @@ namespace Lucene.Net.Search
         protected readonly Q m_query;
 
         /// <summary>
-        /// Wrap a <seealso cref="MultiTermQuery"/> as a Filter.
+        /// Wrap a <see cref="MultiTermQuery"/> as a <see cref="Filter"/>.
         /// </summary>
         protected internal MultiTermQueryWrapperFilter(Q query)
         {
@@ -98,7 +98,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Returns a DocIdSet with documents that should be permitted in search
+        /// Returns a <see cref="DocIdSet"/> with documents that should be permitted in search
         /// results.
         /// </summary>
         public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/NGramPhraseQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/NGramPhraseQuery.cs b/src/Lucene.Net/Search/NGramPhraseQuery.cs
index 2ce79ee..2f208ae 100644
--- a/src/Lucene.Net/Search/NGramPhraseQuery.cs
+++ b/src/Lucene.Net/Search/NGramPhraseQuery.cs
@@ -24,12 +24,11 @@ namespace Lucene.Net.Search
     using Term = Lucene.Net.Index.Term;
 
     /// <summary>
-    /// this is a <seealso cref="PhraseQuery"/> which is optimized for n-gram phrase query.
+    /// This is a <see cref="PhraseQuery"/> which is optimized for n-gram phrase query.
     /// For example, when you query "ABCD" on a 2-gram field, you may want to use
-    /// NGramPhraseQuery rather than <seealso cref="PhraseQuery"/>, because NGramPhraseQuery
-    /// will <seealso cref="#rewrite(IndexReader)"/> the query to "AB/0 CD/2", while <seealso cref="PhraseQuery"/>
+    /// <see cref="NGramPhraseQuery"/> rather than <see cref="PhraseQuery"/>, because <see cref="NGramPhraseQuery"/>
+    /// will <see cref="Rewrite(IndexReader)"/> the query to "AB/0 CD/2", while <see cref="PhraseQuery"/>
     /// will query "AB/0 BC/1 CD/2" (where term/position).
-    ///
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -93,7 +92,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Returns true iff <code>o</code> is equal to this. </summary>
+        /// Returns <c>true</c> if <paramref name="o"/> is equal to this. </summary>
         public override bool Equals(object o)
         {
             if (!(o is NGramPhraseQuery))

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/NumericRangeFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/NumericRangeFilter.cs b/src/Lucene.Net/Search/NumericRangeFilter.cs
index 5900506..f42c87d 100644
--- a/src/Lucene.Net/Search/NumericRangeFilter.cs
+++ b/src/Lucene.Net/Search/NumericRangeFilter.cs
@@ -20,26 +20,25 @@ namespace Lucene.Net.Search
      */
 
     /// <summary>
-    /// A <seealso cref="Filter"/> that only accepts numeric values within
+    /// A <see cref="Filter"/> that only accepts numeric values within
     /// a specified range. To use this, you must first index the
-    /// numeric values using <seealso cref="IntField"/>, {@link
-    /// FloatField}, <seealso cref="LongField"/> or <seealso cref="DoubleField"/> (expert: {@link
-    /// NumericTokenStream}).
+    /// numeric values using <see cref="Documents.Int32Field"/>, 
+    /// <see cref="Documents.SingleField"/>, <see cref="Documents.Int64Field"/> or <see cref="Documents.DoubleField"/> (expert:
+    /// <see cref="Analysis.NumericTokenStream"/>).
     ///
-    /// <p>You create a new NumericRangeFilter with the static
+    /// <para/>You create a new <see cref="NumericRangeFilter"/> with the static
     /// factory methods, eg:
     ///
-    /// <pre class="prettyprint">
-    /// Filter f = NumericRangeFilter.newFloatRange("weight", 0.03f, 0.10f, true, true);
-    /// </pre>
+    /// <code>
+    /// Filter f = NumericRangeFilter.NewFloatRange("weight", 0.03f, 0.10f, true, true);
+    /// </code>
     ///
-    /// accepts all documents whose float valued "weight" field
+    /// Accepts all documents whose float valued "weight" field
     /// ranges from 0.03 to 0.10, inclusive.
-    /// See <seealso cref="NumericRangeQuery"/> for details on how Lucene
+    /// See <see cref="NumericRangeQuery"/> for details on how Lucene
     /// indexes and searches numeric valued fields.
-    ///
+    /// <para/>
     /// @since 2.9
-    ///
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -56,14 +55,14 @@ namespace Lucene.Net.Search
         // LUCENENET NOTE: Static methods were moved into NumericRangeFilter class
 
         /// <summary>
-        /// Returns <code>true</code> if the lower endpoint is inclusive </summary>
+        /// Returns <c>true</c> if the lower endpoint is inclusive </summary>
         public bool IncludesMin
         {
             get { return m_query.IncludesMin; }
         }
 
         /// <summary>
-        /// Returns <code>true</code> if the upper endpoint is inclusive </summary>
+        /// Returns <c>true</c> if the upper endpoint is inclusive </summary>
         public bool IncludesMax
         {
             get { return m_query.IncludesMax; }
@@ -100,13 +99,17 @@ namespace Lucene.Net.Search
         }
     }
 
+    /// <summary>
+    /// LUCENENET specific static class to provide access to static methods without referring to the
+    /// <see cref="NumericRangeFilter{T}"/>'s generic closing type.
+    /// </summary>
     public static class NumericRangeFilter
     {
         /// <summary>
-        /// Factory that creates a <code>NumericRangeFilter</code>, that filters a <code>long</code>
-        /// range using the given <a href="NumericRangeQuery.html#precisionStepDesc"><code>precisionStep</code></a>.
+        /// Factory that creates a <see cref="NumericRangeFilter"/>, that filters a <see cref="long"/>
+        /// range using the given <see cref="NumericRangeQuery{T}.PrecisionStep"/>.
         /// You can have half-open ranges (which are in fact &lt;/&lt;= or &gt;/&gt;= queries)
-        /// by setting the min or max value to <code>null</code>. By setting inclusive to false, it will
+        /// by setting the min or max value to <c>null</c>. By setting inclusive to <c>false</c>, it will
         /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
         /// <para/>
         /// NOTE: This was newLongRange() in Lucene
@@ -117,10 +120,10 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Factory that creates a <code>NumericRangeFilter</code>, that queries a <code>long</code>
-        /// range using the default <code>precisionStep</code> <seealso cref="NumericUtils#PRECISION_STEP_DEFAULT"/> (4).
+        /// Factory that creates a <see cref="NumericRangeFilter"/>, that queries a <see cref="long"/>
+        /// range using the default <see cref="NumericRangeQuery{T}.PrecisionStep"/> <see cref="Util.NumericUtils.PRECISION_STEP_DEFAULT"/> (4).
         /// You can have half-open ranges (which are in fact &lt;/&lt;= or &gt;/&gt;= queries)
-        /// by setting the min or max value to <code>null</code>. By setting inclusive to false, it will
+        /// by setting the min or max value to <c>null</c>. By setting inclusive to <c>false</c>, it will
         /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
         /// <para/>
         /// NOTE: This was newLongRange() in Lucene
@@ -131,10 +134,10 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Factory that creates a <code>NumericRangeFilter</code>, that filters a <code>int</code>
-        /// range using the given <a href="NumericRangeQuery.html#precisionStepDesc"><code>precisionStep</code></a>.
+        /// Factory that creates a <see cref="NumericRangeFilter"/>, that filters a <see cref="int"/>
+        /// range using the given <see cref="NumericRangeQuery{T}.PrecisionStep"/>.
         /// You can have half-open ranges (which are in fact &lt;/&lt;= or &gt;/&gt;= queries)
-        /// by setting the min or max value to <code>null</code>. By setting inclusive to false, it will
+        /// by setting the min or max value to <c>null</c>. By setting inclusive to <c>false</c>, it will
         /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
         /// <para/>
         /// NOTE: This was newIntRange() in Lucene
@@ -145,10 +148,10 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Factory that creates a <code>NumericRangeFilter</code>, that queries a <code>int</code>
-        /// range using the default <code>precisionStep</code> <seealso cref="NumericUtils#PRECISION_STEP_DEFAULT"/> (4).
+        /// Factory that creates a <see cref="NumericRangeFilter"/>, that queries a <see cref="int"/>
+        /// range using the default <see cref="NumericRangeQuery{T}.PrecisionStep"/> <see cref="Util.NumericUtils.PRECISION_STEP_DEFAULT"/> (4).
         /// You can have half-open ranges (which are in fact &lt;/&lt;= or &gt;/&gt;= queries)
-        /// by setting the min or max value to <code>null</code>. By setting inclusive to false, it will
+        /// by setting the min or max value to <c>null</c>. By setting inclusive to <c>false</c>, it will
         /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
         /// <para/>
         /// NOTE: This was newIntRange() in Lucene
@@ -159,12 +162,12 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Factory that creates a <code>NumericRangeFilter</code>, that filters a <code>double</code>
-        /// range using the given <a href="NumericRangeQuery.html#precisionStepDesc"><code>precisionStep</code></a>.
+        /// Factory that creates a <see cref="NumericRangeFilter"/>, that filters a <see cref="double"/>
+        /// range using the given <see cref="NumericRangeQuery{T}.PrecisionStep"/>.
         /// You can have half-open ranges (which are in fact &lt;/&lt;= or &gt;/&gt;= queries)
-        /// by setting the min or max value to <code>null</code>.
-        /// <seealso cref="Double#NaN"/> will never match a half-open range, to hit {@code NaN} use a query
-        /// with {@code min == max == Double.NaN}. By setting inclusive to false, it will
+        /// by setting the min or max value to <c>null</c>.
+        /// <see cref="double.NaN"/> will never match a half-open range, to hit <c>NaN</c> use a query
+        /// with <c>min == max == System.Double.NaN</c>. By setting inclusive to <c>false</c>, it will
         /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
         /// </summary>
         public static NumericRangeFilter<double> NewDoubleRange(string field, int precisionStep, double? min, double? max, bool minInclusive, bool maxInclusive)
@@ -173,12 +176,12 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Factory that creates a <code>NumericRangeFilter</code>, that queries a <code>double</code>
-        /// range using the default <code>precisionStep</code> <seealso cref="NumericUtils#PRECISION_STEP_DEFAULT"/> (4).
+        /// Factory that creates a <see cref="NumericRangeFilter"/>, that queries a <see cref="double"/>
+        /// range using the default <see cref="NumericRangeQuery{T}.PrecisionStep"/> <see cref="Util.NumericUtils.PRECISION_STEP_DEFAULT"/> (4).
         /// You can have half-open ranges (which are in fact &lt;/&lt;= or &gt;/&gt;= queries)
-        /// by setting the min or max value to <code>null</code>.
-        /// <seealso cref="Double#NaN"/> will never match a half-open range, to hit {@code NaN} use a query
-        /// with {@code min == max == Double.NaN}. By setting inclusive to false, it will
+        /// by setting the min or max value to <c>null</c>.
+        /// <see cref="double.NaN"/> will never match a half-open range, to hit <c>NaN</c> use a query
+        /// with <c>min == max == System.Double.NaN</c>. By setting inclusive to <c>false</c>, it will
         /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
         /// </summary>
         public static NumericRangeFilter<double> NewDoubleRange(string field, double? min, double? max, bool minInclusive, bool maxInclusive)
@@ -187,12 +190,12 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Factory that creates a <code>NumericRangeFilter</code>, that filters a <code>float</code>
-        /// range using the given <a href="NumericRangeQuery.html#precisionStepDesc"><code>precisionStep</code></a>.
+        /// Factory that creates a <see cref="NumericRangeFilter"/>, that filters a <see cref="float"/>
+        /// range using the given <see cref="NumericRangeQuery{T}.PrecisionStep"/>.
         /// You can have half-open ranges (which are in fact &lt;/&lt;= or &gt;/&gt;= queries)
-        /// by setting the min or max value to <code>null</code>.
-        /// <seealso cref="Float#NaN"/> will never match a half-open range, to hit {@code NaN} use a query
-        /// with {@code min == max == Float.NaN}. By setting inclusive to false, it will
+        /// by setting the min or max value to <c>null</c>.
+        /// <see cref="float.NaN"/> will never match a half-open range, to hit <c>NaN</c> use a query
+        /// with <c>min == max == System.Single.NaN</c>. By setting inclusive to <c>false</c>, it will
         /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
         /// <para/>
         /// NOTE: This was newFloatRange() in Lucene
@@ -203,12 +206,12 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Factory that creates a <code>NumericRangeFilter</code>, that queries a <code>float</code>
-        /// range using the default <code>precisionStep</code> <seealso cref="NumericUtils#PRECISION_STEP_DEFAULT"/> (4).
+        /// Factory that creates a <see cref="NumericRangeFilter"/>, that queries a <see cref="float"/>
+        /// range using the default <see cref="NumericRangeQuery{T}.PrecisionStep"/> <see cref="Util.NumericUtils.PRECISION_STEP_DEFAULT"/> (4).
         /// You can have half-open ranges (which are in fact &lt;/&lt;= or &gt;/&gt;= queries)
-        /// by setting the min or max value to <code>null</code>.
-        /// <seealso cref="Float#NaN"/> will never match a half-open range, to hit {@code NaN} use a query
-        /// with {@code min == max == Float.NaN}. By setting inclusive to false, it will
+        /// by setting the min or max value to <c>null</c>.
+        /// <see cref="float.NaN"/> will never match a half-open range, to hit <c>NaN</c> use a query
+        /// with <c>min == max == System.Single.NaN</c>. By setting inclusive to <c>false</c>, it will
         /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
         /// <para/>
         /// NOTE: This was newFloatRange() in Lucene

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/NumericRangeQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/NumericRangeQuery.cs b/src/Lucene.Net/Search/NumericRangeQuery.cs
index 2c97b1a..344bc4d 100644
--- a/src/Lucene.Net/Search/NumericRangeQuery.cs
+++ b/src/Lucene.Net/Search/NumericRangeQuery.cs
@@ -32,135 +32,135 @@ namespace Lucene.Net.Search
     using ToStringUtils = Lucene.Net.Util.ToStringUtils;
 
     /// <summary>
-    /// <p>A <seealso cref="Query"/> that matches numeric values within a
+    /// <para>A <see cref="Query"/> that matches numeric values within a
     /// specified range.  To use this, you must first index the
-    /// numeric values using <seealso cref="Int32Field"/>, {@link
-    /// FloatField}, <seealso cref="Int64Field"/> or <seealso cref="DoubleField"/> (expert: {@link
-    /// NumericTokenStream}).  If your terms are instead textual,
-    /// you should use <seealso cref="TermRangeQuery"/>.  {@link
-    /// NumericRangeFilter} is the filter equivalent of this
-    /// query.</p>
+    /// numeric values using <see cref="Int32Field"/>, 
+    /// <see cref="SingleField"/>, <see cref="Int64Field"/> or <see cref="DoubleField"/> (expert: 
+    /// <see cref="Analysis.NumericTokenStream"/>).  If your terms are instead textual,
+    /// you should use <see cref="TermRangeQuery"/>.  
+    /// <see cref="NumericRangeFilter"/> is the filter equivalent of this
+    /// query.</para>
     ///
-    /// <p>You create a new NumericRangeQuery with the static
+    /// <para>You create a new <see cref="NumericRangeQuery{T}"/> with the static
     /// factory methods, eg:
     ///
-    /// <pre class="prettyprint">
-    /// Query q = NumericRangeQuery.newFloatRange("weight", 0.03f, 0.10f, true, true);
-    /// </pre>
+    /// <code>
+    /// Query q = NumericRangeQuery.NewFloatRange("weight", 0.03f, 0.10f, true, true);
+    /// </code>
     ///
-    /// matches all documents whose float valued "weight" field
-    /// ranges from 0.03 to 0.10, inclusive.
+    /// matches all documents whose <see cref="float"/> valued "weight" field
+    /// ranges from 0.03 to 0.10, inclusive.</para>
     ///
-    /// <p>The performance of NumericRangeQuery is much better
-    /// than the corresponding <seealso cref="TermRangeQuery"/> because the
+    /// <para>The performance of <see cref="NumericRangeQuery{T}"/> is much better
+    /// than the corresponding <see cref="TermRangeQuery"/> because the
     /// number of terms that must be searched is usually far
-    /// fewer, thanks to trie indexing, described below.</p>
+    /// fewer, thanks to trie indexing, described below.</para>
     ///
-    /// <p>You can optionally specify a <a
-    /// href="#precisionStepDesc"><code>precisionStep</code></a>
-    /// when creating this query.  this is necessary if you've
+    /// <para>You can optionally specify a <a
+    /// href="#precisionStepDesc"><see cref="precisionStep"/></a>
+    /// when creating this query.  This is necessary if you've
     /// changed this configuration from its default (4) during
     /// indexing.  Lower values consume more disk space but speed
     /// up searching.  Suitable values are between <b>1</b> and
     /// <b>8</b>. A good starting point to test is <b>4</b>,
-    /// which is the default value for all <code>Numeric*</code>
+    /// which is the default value for all <c>Numeric*</c>
     /// classes.  See <a href="#precisionStepDesc">below</a> for
-    /// details.
+    /// details.</para>
     ///
-    /// <p>this query defaults to {@linkplain
-    /// MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}.
+    /// <para>This query defaults to 
+    /// <see cref="MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT"/>.
     /// With precision steps of &lt;=4, this query can be run with
-    /// one of the BooleanQuery rewrite methods without changing
-    /// BooleanQuery's default max clause count.
+    /// one of the <see cref="BooleanQuery"/> rewrite methods without changing
+    /// <see cref="BooleanQuery"/>'s default max clause count.</para>
     ///
-    /// <br><h3>How it works</h3>
-    ///
-    /// <p>See the publication about <a target="_blank" href="http://www.panfmp.org">panFMP</a>,
-    /// where this algorithm was described (referred to as <code>TrieRangeQuery</code>):
+    /// <para/><h3>How it works</h3>
     ///
+    /// <para>See the publication about <a target="_blank" href="http://www.panfmp.org">panFMP</a>,
+    /// where this algorithm was described (referred to as <c>TrieRangeQuery</c>):
+    /// </para>
     /// <blockquote><strong>Schindler, U, Diepenbroek, M</strong>, 2008.
     /// <em>Generic XML-based Framework for Metadata Portals.</em>
     /// Computers &amp; Geosciences 34 (12), 1947-1955.
     /// <a href="http://dx.doi.org/10.1016/j.cageo.2008.02.023"
     /// target="_blank">doi:10.1016/j.cageo.2008.02.023</a></blockquote>
     ///
-    /// <p><em>A quote from this paper:</em> Because Apache Lucene is a full-text
+    /// <para><em>A quote from this paper:</em> Because Apache Lucene is a full-text
     /// search engine and not a conventional database, it cannot handle numerical ranges
     /// (e.g., field value is inside user defined bounds, even dates are numerical values).
     /// We have developed an extension to Apache Lucene that stores
     /// the numerical values in a special string-encoded format with variable precision
-    /// (all numerical values like doubles, longs, floats, and ints are converted to
+    /// (all numerical values like <see cref="double"/>s, <see cref="long"/>s, <see cref="float"/>s, and <see cref="int"/>s are converted to
     /// lexicographic sortable string representations and stored with different precisions
     /// (for a more detailed description of how the values are stored,
-    /// see <seealso cref="NumericUtils"/>). A range is then divided recursively into multiple intervals for searching:
+    /// see <see cref="NumericUtils"/>). A range is then divided recursively into multiple intervals for searching:
     /// The center of the range is searched only with the lowest possible precision in the <em>trie</em>,
-    /// while the boundaries are matched more exactly. this reduces the number of terms dramatically.</p>
+    /// while the boundaries are matched more exactly. This reduces the number of terms dramatically.</para>
     ///
-    /// <p>For the variant that stores long values in 8 different precisions (each reduced by 8 bits) that
+    /// <para>For the variant that stores long values in 8 different precisions (each reduced by 8 bits) that
     /// uses a lowest precision of 1 byte, the index contains only a maximum of 256 distinct values in the
     /// lowest precision. Overall, a range could consist of a theoretical maximum of
     /// <code>7*255*2 + 255 = 3825</code> distinct terms (when there is a term for every distinct value of an
     /// 8-byte-number in the index and the range covers almost all of them; a maximum of 255 distinct values is used
     /// because it would always be possible to reduce the full 256 values to one term with degraded precision).
     /// In practice, we have seen up to 300 terms in most cases (index with 500,000 metadata records
-    /// and a uniform value distribution).</p>
+    /// and a uniform value distribution).</para>
     ///
-    /// <a name="precisionStepDesc"><h3>Precision Step</h3>
-    /// <p>You can choose any <code>precisionStep</code> when encoding values.
+    /// <a name="precisionStepDesc"><h3>Precision Step</h3></a>
+    /// <para/>You can choose any <see cref="precisionStep"/> when encoding values.
     /// Lower step values mean more precisions and so more terms in index (and index gets larger). The number
-    /// of indexed terms per value is (those are generated by <seealso cref="NumericTokenStream"/>):
-    /// <p style="font-family:serif">
-    /// &nbsp;&nbsp;indexedTermsPerValue = <b>ceil</b><big>(</big>bitsPerValue / precisionStep<big>)</big>
-    /// </p>
+    /// of indexed terms per value is (those are generated by <see cref="Analysis.NumericTokenStream"/>):
+    /// <para>
+    /// &#160;&#160;indexedTermsPerValue = <b>ceil</b><big>(</big>bitsPerValue / precisionStep<big>)</big>
+    /// </para>
     /// As the lower precision terms are shared by many values, the additional terms only
-    /// slightly grow the term dictionary (approx. 7% for <code>precisionStep=4</code>), but have a larger
+    /// slightly grow the term dictionary (approx. 7% for <c>precisionStep=4</c>), but have a larger
     /// impact on the postings (the postings file will have  more entries, as every document is linked to
-    /// <code>indexedTermsPerValue</code> terms instead of one). The formula to estimate the growth
+    /// <c>indexedTermsPerValue</c> terms instead of one). The formula to estimate the growth
     /// of the term dictionary in comparison to one term per value:
-    /// <p>
+    /// <para>
     /// <!-- the formula in the alt attribute was transformed from latex to PNG with http://1.618034.com/latex.php (with 110 dpi): -->
-    /// &nbsp;&nbsp;<img src="doc-files/nrq-formula-1.png" alt="\mathrm{termDictOverhead} = \sum\limits_{i=0}^{\mathrm{indexedTermsPerValue}-1} \frac{1}{2^{\mathrm{precisionStep}\cdot i}}" />
-    /// </p>
-    /// <p>On the other hand, if the <code>precisionStep</code> is smaller, the maximum number of terms to match reduces,
+    /// &#160;&#160;<img src="doc-files/nrq-formula-1.png" alt="\mathrm{termDictOverhead} = \sum\limits_{i=0}^{\mathrm{indexedTermsPerValue}-1} \frac{1}{2^{\mathrm{precisionStep}\cdot i}}" />
+    /// </para>
+    /// <para>On the other hand, if the <see cref="precisionStep"/> is smaller, the maximum number of terms to match reduces,
     /// which optimizes query speed. The formula to calculate the maximum number of terms that will be visited while
     /// executing the query is:
-    /// <p>
+    /// </para>
+    /// <para>
     /// <!-- the formula in the alt attribute was transformed from latex to PNG with http://1.618034.com/latex.php (with 110 dpi): -->
-    /// &nbsp;&nbsp;<img src="doc-files/nrq-formula-2.png" alt="\mathrm{maxQueryTerms} = \left[ \left( \mathrm{indexedTermsPerValue} - 1 \right) \cdot \left(2^\mathrm{precisionStep} - 1 \right) \cdot 2 \right] + \left( 2^\mathrm{precisionStep} - 1 \right)" />
-    /// </p>
-    /// <p>For longs stored using a precision step of 4, <code>maxQueryTerms = 15*15*2 + 15 = 465</code>, and for a precision
-    /// step of 2, <code>maxQueryTerms = 31*3*2 + 3 = 189</code>. But the faster search speed is reduced by more seeking
-    /// in the term enum of the index. Because of this, the ideal <code>precisionStep</code> value can only
+    /// &#160;&#160;<img src="doc-files/nrq-formula-2.png" alt="\mathrm{maxQueryTerms} = \left[ \left( \mathrm{indexedTermsPerValue} - 1 \right) \cdot \left(2^\mathrm{precisionStep} - 1 \right) \cdot 2 \right] + \left( 2^\mathrm{precisionStep} - 1 \right)" />
+    /// </para>
+    /// <para>For longs stored using a precision step of 4, <c>maxQueryTerms = 15*15*2 + 15 = 465</c>, and for a precision
+    /// step of 2, <c>maxQueryTerms = 31*3*2 + 3 = 189</c>. But the faster search speed is reduced by more seeking
+    /// in the term enum of the index. Because of this, the ideal <see cref="precisionStep"/> value can only
     /// be found out by testing. <b>Important:</b> You can index with a lower precision step value and test search speed
-    /// using a multiple of the original step value.</p>
+    /// using a multiple of the original step value.</para>
     ///
-    /// <p>Good values for <code>precisionStep</code> are depending on usage and data type:
-    /// <ul>
-    ///  <li>The default for all data types is <b>4</b>, which is used, when no <code>precisionStep</code> is given.
-    ///  <li>Ideal value in most cases for <em>64 bit</em> data types <em>(long, double)</em> is <b>6</b> or <b>8</b>.
-    ///  <li>Ideal value in most cases for <em>32 bit</em> data types <em>(int, float)</em> is <b>4</b>.
-    ///  <li>For low cardinality fields larger precision steps are good. If the cardinality is &lt; 100, it is
-    ///  fair to use <seealso cref="int.MaxValue"/> (see below).
-    ///  <li>Steps <b>&gt;=64</b> for <em>long/double</em> and <b>&gt;=32</b> for <em>int/float</em> produces one token
-    ///  per value in the index and querying is as slow as a conventional <seealso cref="TermRangeQuery"/>. But it can be used
-    ///  to produce fields, that are solely used for sorting (in this case simply use <seealso cref="int.MaxValue"/> as
-    ///  <code>precisionStep</code>). Using <seealso cref="Int32Field"/>,
-    ///  <seealso cref="Int64Field"/>, <seealso cref="SingleField"/> or <seealso cref="DoubleField"/> for sorting
+    /// <para>Good values for <see cref="precisionStep"/> are depending on usage and data type:</para>
+    /// <list type="bullet">
+    ///  <item><description>The default for all data types is <b>4</b>, which is used, when no <code>precisionStep</code> is given.</description></item>
+    ///  <item><description>Ideal value in most cases for <em>64 bit</em> data types <em>(long, double)</em> is <b>6</b> or <b>8</b>.</description></item>
+    ///  <item><description>Ideal value in most cases for <em>32 bit</em> data types <em>(int, float)</em> is <b>4</b>.</description></item>
+    ///  <item><description>For low cardinality fields larger precision steps are good. If the cardinality is &lt; 100, it is
+    ///  fair to use <see cref="int.MaxValue"/> (see below).</description></item>
+    ///  <item><description>Steps <b>&gt;=64</b> for <em>long/double</em> and <b>&gt;=32</b> for <em>int/float</em> produces one token
+    ///  per value in the index and querying is as slow as a conventional <see cref="TermRangeQuery"/>. But it can be used
+    ///  to produce fields, that are solely used for sorting (in this case simply use <see cref="int.MaxValue"/> as
+    ///  <see cref="precisionStep"/>). Using <see cref="Int32Field"/>,
+    ///  <see cref="Int64Field"/>, <see cref="SingleField"/> or <see cref="DoubleField"/> for sorting
     ///  is ideal, because building the field cache is much faster than with text-only numbers.
     ///  These fields have one term per value and therefore also work with term enumeration for building distinct lists
     ///  (e.g. facets / preselected values to search for).
-    ///  Sorting is also possible with range query optimized fields using one of the above <code>precisionSteps</code>.
-    /// </ul>
+    ///  Sorting is also possible with range query optimized fields using one of the above <see cref="precisionStep"/>s.</description></item>
+    /// </list>
     ///
-    /// <p>Comparisons of the different types of RangeQueries on an index with about 500,000 docs showed
-    /// that <seealso cref="TermRangeQuery"/> in boolean rewrite mode (with raised <seealso cref="BooleanQuery"/> clause count)
-    /// took about 30-40 secs to complete, <seealso cref="TermRangeQuery"/> in constant score filter rewrite mode took 5 secs
+    /// <para>Comparisons of the different types of RangeQueries on an index with about 500,000 docs showed
+    /// that <see cref="TermRangeQuery"/> in boolean rewrite mode (with raised <see cref="BooleanQuery"/> clause count)
+    /// took about 30-40 secs to complete, <see cref="TermRangeQuery"/> in constant score filter rewrite mode took 5 secs
     /// and executing this class took &lt;100ms to complete (on an Opteron64 machine, Java 1.5, 8 bit
-    /// precision step). this query type was developed for a geographic portal, where the performance for
-    /// e.g. bounding boxes or exact date/time stamps is important.</p>
+    /// precision step). This query type was developed for a geographic portal, where the performance for
+    /// e.g. bounding boxes or exact date/time stamps is important.</para>
     ///
     /// @since 2.9
-    ///
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -196,14 +196,14 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Returns <code>true</code> if the lower endpoint is inclusive </summary>
+        /// Returns <c>true</c> if the lower endpoint is inclusive </summary>
         public bool IncludesMin
         {
             get { return minInclusive; }
         }
 
         /// <summary>
-        /// Returns <code>true</code> if the upper endpoint is inclusive </summary>
+        /// Returns <c>true</c> if the upper endpoint is inclusive </summary>
         public bool IncludesMax
         {
             get { return maxInclusive; }
@@ -311,14 +311,14 @@ namespace Lucene.Net.Search
         internal static readonly int INT32_POSITIVE_INFINITY = NumericUtils.SingleToSortableInt32(float.PositiveInfinity);
 
         /// <summary>
-        /// Subclass of FilteredTermsEnum for enumerating all terms that match the
+        /// Subclass of <see cref="FilteredTermsEnum"/> for enumerating all terms that match the
         /// sub-ranges for trie range queries, using flex API.
-        /// <p>
+        /// <para/>
         /// WARNING: this term enumeration is not guaranteed to be always ordered by
-        /// <seealso cref="Term#compareTo"/>.
-        /// The ordering depends on how <seealso cref="NumericUtils#splitLongRange"/> and
-        /// <seealso cref="NumericUtils#splitIntRange"/> generates the sub-ranges. For
-        /// <seealso cref="MultiTermQuery"/> ordering is not relevant.
+        /// <see cref="Index.Term.CompareTo(Index.Term)"/>.
+        /// The ordering depends on how <see cref="NumericUtils.SplitInt64Range(NumericUtils.Int64RangeBuilder, int, long, long)"/> and
+        /// <see cref="NumericUtils.SplitInt32Range(NumericUtils.Int32RangeBuilder, int, int, int)"/> generates the sub-ranges. For
+        /// <see cref="MultiTermQuery"/> ordering is not relevant.
         /// </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]
@@ -532,13 +532,17 @@ namespace Lucene.Net.Search
         }
     }
 
+    /// <summary>
+    /// LUCENENET specific class to provide access to static factory metods of <see cref="NumericRangeQuery{T}"/>
+    /// without referring to its genereic closing type.
+    /// </summary>
     public static class NumericRangeQuery
     {
         /// <summary>
-        /// Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>long</code>
-        /// range using the given <a href="#precisionStepDesc"><code>precisionStep</code></a>.
+        /// Factory that creates a <see cref="NumericRangeQuery{T}"/>, that queries a <see cref="long"/>
+        /// range using the given <a href="#precisionStepDesc"><see cref="NumericRangeQuery{T}.precisionStep"/></a>.
         /// You can have half-open ranges (which are in fact &lt;/&lt;= or &gt;/&gt;= queries)
-        /// by setting the min or max value to <code>null</code>. By setting inclusive to false, it will
+        /// by setting the min or max value to <c>null</c>. By setting inclusive to <c>false</c>, it will
         /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
         /// <para/>
         /// NOTE: This was newLongRange() in Lucene
@@ -549,10 +553,10 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>long</code>
-        /// range using the default <code>precisionStep</code> <seealso cref="NumericUtils#PRECISION_STEP_DEFAULT"/> (4).
+        /// Factory that creates a <see cref="NumericRangeQuery{T}"/>, that queries a <see cref="long"/>
+        /// range using the default <see cref="NumericRangeQuery{T}.precisionStep"/> <see cref="NumericUtils.PRECISION_STEP_DEFAULT"/> (4).
         /// You can have half-open ranges (which are in fact &lt;/&lt;= or &gt;/&gt;= queries)
-        /// by setting the min or max value to <code>null</code>. By setting inclusive to false, it will
+        /// by setting the min or max value to <c>null</c>. By setting inclusive to <c>false</c>, it will
         /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
         /// <para/>
         /// NOTE: This was newLongRange() in Lucene
@@ -563,10 +567,10 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>int</code>
-        /// range using the given <a href="#precisionStepDesc"><code>precisionStep</code></a>.
+        /// Factory that creates a <see cref="NumericRangeQuery{T}"/>, that queries a <see cref="int"/>
+        /// range using the given <a href="#precisionStepDesc"><see cref="NumericRangeQuery{T}.precisionStep"/></a>.
         /// You can have half-open ranges (which are in fact &lt;/&lt;= or &gt;/&gt;= queries)
-        /// by setting the min or max value to <code>null</code>. By setting inclusive to false, it will
+        /// by setting the min or max value to <c>null</c>. By setting inclusive to <c>false</c>, it will
         /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
         /// <para/>
         /// NOTE: This was newIntRange() in Lucene
@@ -577,10 +581,10 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>int</code>
-        /// range using the default <code>precisionStep</code> <seealso cref="NumericUtils#PRECISION_STEP_DEFAULT"/> (4).
+        /// Factory that creates a <see cref="NumericRangeQuery{T}"/>, that queries a <see cref="int"/>
+        /// range using the default <see cref="NumericRangeQuery{T}.precisionStep"/> <see cref="NumericUtils.PRECISION_STEP_DEFAULT"/> (4).
         /// You can have half-open ranges (which are in fact &lt;/&lt;= or &gt;/&gt;= queries)
-        /// by setting the min or max value to <code>null</code>. By setting inclusive to false, it will
+        /// by setting the min or max value to <c>null</c>. By setting inclusive to <c>false</c>, it will
         /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
         /// <para/>
         /// NOTE: This was newIntRange() in Lucene
@@ -591,12 +595,12 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>double</code>
-        /// range using the given <a href="#precisionStepDesc"><code>precisionStep</code></a>.
+        /// Factory that creates a <see cref="NumericRangeQuery{T}"/>, that queries a <see cref="double"/>
+        /// range using the given <a href="#precisionStepDesc"><see cref="NumericRangeQuery{T}.precisionStep"/></a>.
         /// You can have half-open ranges (which are in fact &lt;/&lt;= or &gt;/&gt;= queries)
-        /// by setting the min or max value to <code>null</code>.
-        /// <seealso cref="Double#NaN"/> will never match a half-open range, to hit {@code NaN} use a query
-        /// with {@code min == max == Double.NaN}.  By setting inclusive to false, it will
+        /// by setting the min or max value to <c>null</c>.
+        /// <see cref="double.NaN"/> will never match a half-open range, to hit <c>NaN</c> use a query
+        /// with <c>min == max == System.Double.NaN</c>.  By setting inclusive to <c>false</c>, it will
         /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
         /// </summary>
         public static NumericRangeQuery<double> NewDoubleRange(string field, int precisionStep, double? min, double? max, bool minInclusive, bool maxInclusive)
@@ -605,12 +609,12 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>double</code>
-        /// range using the default <code>precisionStep</code> <seealso cref="NumericUtils#PRECISION_STEP_DEFAULT"/> (4).
+        /// Factory that creates a <see cref="NumericRangeQuery{T}"/>, that queries a <see cref="double"/>
+        /// range using the default <see cref="NumericRangeQuery{T}.precisionStep"/> <see cref="NumericUtils.PRECISION_STEP_DEFAULT"/> (4).
         /// You can have half-open ranges (which are in fact &lt;/&lt;= or &gt;/&gt;= queries)
-        /// by setting the min or max value to <code>null</code>.
-        /// <seealso cref="Double#NaN"/> will never match a half-open range, to hit {@code NaN} use a query
-        /// with {@code min == max == Double.NaN}.  By setting inclusive to false, it will
+        /// by setting the min or max value to <c>null</c>.
+        /// <see cref="double.NaN"/> will never match a half-open range, to hit <c>NaN</c> use a query
+        /// with <c>min == max == System.Double.NaN</c>.  By setting inclusive to <c>false</c>, it will
         /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
         /// </summary>
         public static NumericRangeQuery<double> NewDoubleRange(string field, double? min, double? max, bool minInclusive, bool maxInclusive)
@@ -619,12 +623,12 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>float</code>
-        /// range using the given <a href="#precisionStepDesc"><code>precisionStep</code></a>.
+        /// Factory that creates a <see cref="NumericRangeQuery{T}"/>, that queries a <see cref="float"/>
+        /// range using the given <a href="#precisionStepDesc"><see cref="NumericRangeQuery{T}.precisionStep"/></a>.
         /// You can have half-open ranges (which are in fact &lt;/&lt;= or &gt;/&gt;= queries)
-        /// by setting the min or max value to <code>null</code>.
-        /// <seealso cref="Float#NaN"/> will never match a half-open range, to hit {@code NaN} use a query
-        /// with {@code min == max == Float.NaN}.  By setting inclusive to false, it will
+        /// by setting the min or max value to <c>null</c>.
+        /// <see cref="float.NaN"/> will never match a half-open range, to hit <c>NaN</c> use a query
+        /// with <c>min == max == System.Single.NaN</c>.  By setting inclusive to <c>false</c>, it will
         /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
         /// <para/>
         /// NOTE: This was newFloatRange() in Lucene
@@ -635,12 +639,12 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>float</code>
-        /// range using the default <code>precisionStep</code> <seealso cref="NumericUtils#PRECISION_STEP_DEFAULT"/> (4).
+        /// Factory that creates a <see cref="NumericRangeQuery{T}"/>, that queries a <see cref="float"/>
+        /// range using the default <see cref="NumericRangeQuery{T}.precisionStep"/> <see cref="NumericUtils.PRECISION_STEP_DEFAULT"/> (4).
         /// You can have half-open ranges (which are in fact &lt;/&lt;= or &gt;/&gt;= queries)
-        /// by setting the min or max value to <code>null</code>.
-        /// <seealso cref="Float#NaN"/> will never match a half-open range, to hit {@code NaN} use a query
-        /// with {@code min == max == Float.NaN}.  By setting inclusive to false, it will
+        /// by setting the min or max value to <c>null</c>.
+        /// <see cref="float.NaN"/> will never match a half-open range, to hit <c>NaN</c> use a query
+        /// with <c>min == max == System.Single.NaN</c>.  By setting inclusive to <c>false</c>, it will
         /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
         /// <para/>
         /// NOTE: This was newFloatRange() in Lucene

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/PhrasePositions.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/PhrasePositions.cs b/src/Lucene.Net/Search/PhrasePositions.cs
index 3e875c0..dc9619a 100644
--- a/src/Lucene.Net/Search/PhrasePositions.cs
+++ b/src/Lucene.Net/Search/PhrasePositions.cs
@@ -75,9 +75,9 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Go to next location of this term current document, and set
-        /// <code>position</code> as <code>location - offset</code>, so that a
-        /// matching exact phrase is easily identified when all PhrasePositions
-        /// have exactly the same <code>position</code>.
+        /// <c>position</c> as <c>location - offset</c>, so that a
+        /// matching exact phrase is easily identified when all <see cref="PhrasePositions"/>
+        /// have exactly the same <c>position</c>.
         /// </summary>
         internal bool NextPosition()
         {
@@ -93,7 +93,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// for debug purposes </summary>
+        /// For debug purposes </summary>
         public override string ToString()
         {
             string s = "d:" + doc + " o:" + offset + " p:" + position + " c:" + count;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/PhraseQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/PhraseQuery.cs b/src/Lucene.Net/Search/PhraseQuery.cs
index 99186db..224eef3 100644
--- a/src/Lucene.Net/Search/PhraseQuery.cs
+++ b/src/Lucene.Net/Search/PhraseQuery.cs
@@ -43,10 +43,10 @@ namespace Lucene.Net.Search
     using ToStringUtils = Lucene.Net.Util.ToStringUtils;
 
     /// <summary>
-    /// A Query that matches documents containing a particular sequence of terms.
-    /// A PhraseQuery is built by QueryParser for input like <code>"new york"</code>.
+    /// A <see cref="Query"/> that matches documents containing a particular sequence of terms.
+    /// A <see cref="PhraseQuery"/> is built by QueryParser for input like <c>"new york"</c>.
     ///
-    /// <p>this query may be combined with other terms or queries with a <seealso cref="BooleanQuery"/>.
+    /// <para/>This query may be combined with other terms or queries with a <see cref="BooleanQuery"/>.
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -67,19 +67,19 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Sets the number of other words permitted between words in query phrase.
-        ///  If zero, then this is an exact phrase search.  For larger values this works
-        ///  like a <code>WITHIN</code> or <code>NEAR</code> operator.
+        /// If zero, then this is an exact phrase search.  For larger values this works
+        /// like a <c>WITHIN</c> or <c>NEAR</c> operator.
         ///
-        ///  <p>The slop is in fact an edit-distance, where the units correspond to
-        ///  moves of terms in the query phrase out of position.  For example, to switch
-        ///  the order of two words requires two moves (the first move places the words
-        ///  atop one another), so to permit re-orderings of phrases, the slop must be
-        ///  at least two.
+        /// <para/>The slop is in fact an edit-distance, where the units correspond to
+        /// moves of terms in the query phrase out of position.  For example, to switch
+        /// the order of two words requires two moves (the first move places the words
+        /// atop one another), so to permit re-orderings of phrases, the slop must be
+        /// at least two.
         ///
-        ///  <p>More exact matches are scored higher than sloppier matches, thus search
-        ///  results are sorted by exactness.
+        /// <para/>More exact matches are scored higher than sloppier matches, thus search
+        /// results are sorted by exactness.
         ///
-        ///  <p>The slop is zero by default, requiring exact matches.
+        /// <para/>The slop is zero by default, requiring exact matches.
         /// </summary>
         public virtual int Slop
         {
@@ -117,7 +117,6 @@ namespace Lucene.Net.Search
         /// The relative position of the term within the phrase is specified explicitly.
         /// this allows e.g. phrases with more than one term at the same position
         /// or phrases with gaps (e.g. in connection with stopwords).
-        ///
         /// </summary>
         public virtual void Add(Term term, int position)
         {
@@ -438,7 +437,7 @@ namespace Lucene.Net.Search
             return new PhraseWeight(this, searcher);
         }
 
-        /// <seealso cref= Lucene.Net.Search.Query#extractTerms(Set) </seealso>
+        /// <seealso cref="Lucene.Net.Search.Query.ExtractTerms(ISet{Term})"/>
         public override void ExtractTerms(ISet<Term> queryTerms)
         {
             queryTerms.UnionWith(terms);
@@ -501,7 +500,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Returns true iff <code>o</code> is equal to this. </summary>
+        /// Returns <c>true</c> if <paramref name="o"/> is equal to this. </summary>
         public override bool Equals(object o)
         {
             if (!(o is PhraseQuery))

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/PositiveScoresOnlyCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/PositiveScoresOnlyCollector.cs b/src/Lucene.Net/Search/PositiveScoresOnlyCollector.cs
index e50e75d..8f5c289 100644
--- a/src/Lucene.Net/Search/PositiveScoresOnlyCollector.cs
+++ b/src/Lucene.Net/Search/PositiveScoresOnlyCollector.cs
@@ -22,8 +22,8 @@ namespace Lucene.Net.Search
     using AtomicReaderContext = Lucene.Net.Index.AtomicReaderContext;
 
     /// <summary>
-    /// A <seealso cref="ICollector"/> implementation which wraps another
-    /// <seealso cref="ICollector"/> and makes sure only documents with
+    /// A <see cref="ICollector"/> implementation which wraps another
+    /// <see cref="ICollector"/> and makes sure only documents with
     /// scores &gt; 0 are collected.
     /// </summary>
 #if FEATURE_SERIALIZABLE

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/PrefixFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/PrefixFilter.cs b/src/Lucene.Net/Search/PrefixFilter.cs
index 8c7ee56..7f39e69 100644
--- a/src/Lucene.Net/Search/PrefixFilter.cs
+++ b/src/Lucene.Net/Search/PrefixFilter.cs
@@ -23,7 +23,7 @@ namespace Lucene.Net.Search
     using Term = Lucene.Net.Index.Term;
 
     /// <summary>
-    /// A Filter that restricts search results to values that have a matching prefix in a given
+    /// A <see cref="Filter"/> that restricts search results to values that have a matching prefix in a given
     /// field.
     /// </summary>
 #if FEATURE_SERIALIZABLE

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/PrefixQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/PrefixQuery.cs b/src/Lucene.Net/Search/PrefixQuery.cs
index 5381aaf..6db8c34 100644
--- a/src/Lucene.Net/Search/PrefixQuery.cs
+++ b/src/Lucene.Net/Search/PrefixQuery.cs
@@ -27,11 +27,11 @@ namespace Lucene.Net.Search
     using ToStringUtils = Lucene.Net.Util.ToStringUtils;
 
     /// <summary>
-    /// A Query that matches documents containing terms with a specified prefix. A PrefixQuery
-    /// is built by QueryParser for input like <code>app*</code>.
+    /// A <see cref="Query"/> that matches documents containing terms with a specified prefix. A <see cref="PrefixQuery"/>
+    /// is built by QueryParser for input like <c>app*</c>.
     ///
-    /// <p>this query uses the {@link
-    /// MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}
+    /// <para/>This query uses the
+    /// <see cref="MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT"/>
     /// rewrite method.
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -42,7 +42,7 @@ namespace Lucene.Net.Search
         private readonly Term _prefix;
 
         /// <summary>
-        /// Constructs a query for terms starting with <code>prefix</code>. </summary>
+        /// Constructs a query for terms starting with <paramref name="prefix"/>. </summary>
         public PrefixQuery(Term prefix)
             : base(prefix.Field)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/PrefixTermsEnum.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/PrefixTermsEnum.cs b/src/Lucene.Net/Search/PrefixTermsEnum.cs
index 025d43f..12888b0 100644
--- a/src/Lucene.Net/Search/PrefixTermsEnum.cs
+++ b/src/Lucene.Net/Search/PrefixTermsEnum.cs
@@ -25,11 +25,11 @@ namespace Lucene.Net.Search
     using TermsEnum = Lucene.Net.Index.TermsEnum;
 
     /// <summary>
-    /// Subclass of FilteredTermEnum for enumerating all terms that match the
+    /// Subclass of <see cref="FilteredTermsEnum"/> for enumerating all terms that match the
     /// specified prefix filter term.
-    /// <p>Term enumerations are always ordered by
-    /// <seealso cref="#getComparer"/>.  Each term in the enumeration is
-    /// greater than all that precede it.</p>
+    /// <para>Term enumerations are always ordered by
+    /// <see cref="TermsEnum.Comparer"/>.  Each term in the enumeration is
+    /// greater than all that precede it.</para>
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/Query.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/Query.cs b/src/Lucene.Net/Search/Query.cs
index 93bfb21..14a8db3 100644
--- a/src/Lucene.Net/Search/Query.cs
+++ b/src/Lucene.Net/Search/Query.cs
@@ -26,23 +26,23 @@ namespace Lucene.Net.Search
 
     /// <summary>
     /// The abstract base class for queries.
-    ///    <p>Instantiable subclasses are:
-    ///    <ul>
-    ///    <li> <seealso cref="TermQuery"/>
-    ///    <li> <seealso cref="BooleanQuery"/>
-    ///    <li> <seealso cref="WildcardQuery"/>
-    ///    <li> <seealso cref="PhraseQuery"/>
-    ///    <li> <seealso cref="PrefixQuery"/>
-    ///    <li> <seealso cref="MultiPhraseQuery"/>
-    ///    <li> <seealso cref="FuzzyQuery"/>
-    ///    <li> <seealso cref="RegexpQuery"/>
-    ///    <li> <seealso cref="TermRangeQuery"/>
-    ///    <li> <seealso cref="NumericRangeQuery"/>
-    ///    <li> <seealso cref="ConstantScoreQuery"/>
-    ///    <li> <seealso cref="DisjunctionMaxQuery"/>
-    ///    <li> <seealso cref="MatchAllDocsQuery"/>
-    ///    </ul>
-    ///    <p>See also the family of <seealso cref="Lucene.Net.Search.Spans Span Queries"/>
+    ///    <para/>Instantiable subclasses are:
+    ///    <list type="bullet">
+    ///    <item><description> <seealso cref="TermQuery"/> </description></item>
+    ///    <item><description> <seealso cref="BooleanQuery"/> </description></item>
+    ///    <item><description> <seealso cref="WildcardQuery"/> </description></item>
+    ///    <item><description> <seealso cref="PhraseQuery"/> </description></item>
+    ///    <item><description> <seealso cref="PrefixQuery"/> </description></item>
+    ///    <item><description> <seealso cref="MultiPhraseQuery"/> </description></item>
+    ///    <item><description> <seealso cref="FuzzyQuery"/> </description></item>
+    ///    <item><description> <seealso cref="RegexpQuery"/> </description></item>
+    ///    <item><description> <seealso cref="TermRangeQuery"/> </description></item>
+    ///    <item><description> <seealso cref="NumericRangeQuery"/> </description></item>
+    ///    <item><description> <seealso cref="ConstantScoreQuery"/> </description></item>
+    ///    <item><description> <seealso cref="DisjunctionMaxQuery"/> </description></item>
+    ///    <item><description> <seealso cref="MatchAllDocsQuery"/> </description></item>
+    ///    </list>
+    ///    <para/>See also the family of Span Queries (<see cref="Lucene.Net.Search.Spans"/>)
     ///       and additional queries available in the <a href="{@docRoot}/../queries/overview-summary.html">Queries module</a>
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -56,9 +56,9 @@ namespace Lucene.Net.Search
 
 
         /// <summary>
-        /// Sets the boost for this query clause to <code>b</code>.  Documents
+        /// Gets or Sets the boost for this query clause.  Documents
         /// matching this clause will (in addition to the normal weightings) have
-        /// their score multiplied by <code>b</code>.
+        /// their score multiplied by <see cref="Boost"/>. The boost is 1.0 by default.
         /// </summary>
         public virtual float Boost
         {
@@ -67,7 +67,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Prints a query to a string, with <code>field</code> assumed to be the
+        /// Prints a query to a string, with <paramref name="field"/> assumed to be the
         /// default field and omitted.
         /// </summary>
         public abstract string ToString(string field);
@@ -80,9 +80,9 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Expert: Constructs an appropriate Weight implementation for this query.
+        /// Expert: Constructs an appropriate <see cref="Weight"/> implementation for this query.
         ///
-        /// <p>
+        /// <para/>
         /// Only implemented by primitive queries, which re-write to themselves.
         /// </summary>
         public virtual Weight CreateWeight(IndexSearcher searcher)
@@ -92,8 +92,8 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Expert: called to re-write queries into primitive queries. For example,
-        /// a PrefixQuery will be rewritten into a BooleanQuery that consists
-        /// of TermQuerys.
+        /// a <see cref="PrefixQuery"/> will be rewritten into a <see cref="BooleanQuery"/> that consists
+        /// of <see cref="TermQuery"/>s.
         /// </summary>
         public virtual Query Rewrite(IndexReader reader)
         {
@@ -102,9 +102,9 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Expert: adds all terms occurring in this query to the terms set. Only
-        /// works if this query is in its <seealso cref="#rewrite rewritten"/> form.
+        /// works if this query is in its rewritten (<see cref="Rewrite(IndexReader)"/>) form.
         /// </summary>
-        /// <exception cref="InvalidOperationException"> if this query is not yet rewritten </exception>
+        /// <exception cref="InvalidOperationException"> If this query is not yet rewritten </exception>
         public virtual void ExtractTerms(ISet<Term> terms)
         {
             // needs to be implemented by query subclasses

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/QueryRescorer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/QueryRescorer.cs b/src/Lucene.Net/Search/QueryRescorer.cs
index 0455789..d434881 100644
--- a/src/Lucene.Net/Search/QueryRescorer.cs
+++ b/src/Lucene.Net/Search/QueryRescorer.cs
@@ -24,9 +24,9 @@ namespace Lucene.Net.Search
     using AtomicReaderContext = Lucene.Net.Index.AtomicReaderContext;
 
     /// <summary>
-    /// A <seealso cref="Rescorer"/> that uses a provided Query to assign
-    ///  scores to the first-pass hits.
-    ///
+    /// A <see cref="Rescorer"/> that uses a provided <see cref="Query"/> to assign
+    /// scores to the first-pass hits.
+    /// <para/>
     /// @lucene.experimental
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -38,7 +38,7 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Sole constructor, passing the 2nd pass query to
-        ///  assign scores to the 1st pass hits.
+        /// assign scores to the 1st pass hits.
         /// </summary>
         public QueryRescorer(Query query)
         {
@@ -47,10 +47,10 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Implement this in a subclass to combine the first pass and
-        /// second pass scores.  If secondPassMatches is false then
+        /// second pass scores.  If <paramref name="secondPassMatches"/> is <c>false</c> then
         /// the second pass query failed to match a hit from the
         /// first pass query, and you should ignore the
-        /// secondPassScore.
+        /// <paramref name="secondPassScore"/>.
         /// </summary>
         protected abstract float Combine(float firstPassScore, bool secondPassMatches, float secondPassScore);
 
@@ -214,8 +214,8 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Sugar API, calling {#rescore} using a simple linear
-        ///  combination of firstPassScore + weight * secondPassScore
+        /// Sugar API, calling <see cref="QueryRescorer.Rescore(IndexSearcher, TopDocs, int)"/> using a simple linear
+        /// combination of firstPassScore + <paramref name="weight"/> * secondPassScore
         /// </summary>
         public static TopDocs Rescore(IndexSearcher searcher, TopDocs topDocs, Query query, double weight, int topN)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/QueryWrapperFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/QueryWrapperFilter.cs b/src/Lucene.Net/Search/QueryWrapperFilter.cs
index fe3f70e..727291f 100644
--- a/src/Lucene.Net/Search/QueryWrapperFilter.cs
+++ b/src/Lucene.Net/Search/QueryWrapperFilter.cs
@@ -26,10 +26,10 @@ namespace Lucene.Net.Search
     /// Constrains search results to only match those which also match a provided
     /// query.
     ///
-    /// <p> this could be used, for example, with a <seealso cref="NumericRangeQuery"/> on a suitably
+    /// <para/> This could be used, for example, with a <see cref="NumericRangeQuery"/> on a suitably
     /// formatted date field to implement date filtering.  One could re-use a single
-    /// CachingWrapperFilter(QueryWrapperFilter) that matches, e.g., only documents modified
-    /// within the last week.  this would only need to be reconstructed once per day.
+    /// <c>CachingWrapperFilter(QueryWrapperFilter)</c> that matches, e.g., only documents modified
+    /// within the last week.  This would only need to be reconstructed once per day.
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -40,7 +40,7 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Constructs a filter which only matches documents matching
-        /// <code>query</code>.
+        /// <paramref name="query"/>.
         /// </summary>
         public QueryWrapperFilter(Query query)
         {
@@ -52,7 +52,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// returns the inner Query </summary>
+        /// Returns the inner Query </summary>
         public Query Query
         {
             get

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/ReferenceManager.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/ReferenceManager.cs b/src/Lucene.Net/Search/ReferenceManager.cs
index 6f4e2f8..8cc4174 100644
--- a/src/Lucene.Net/Search/ReferenceManager.cs
+++ b/src/Lucene.Net/Search/ReferenceManager.cs
@@ -26,16 +26,15 @@ namespace Lucene.Net.Search
 
     /// <summary>
     /// Utility class to safely share instances of a certain type across multiple
-    /// threads, while periodically refreshing them. this class ensures each
+    /// threads, while periodically refreshing them. This class ensures each
     /// reference is closed only once all threads have finished using it. It is
-    /// recommended to consult the documentation of <seealso cref="ReferenceManager"/>
-    /// implementations for their <seealso cref="#maybeRefresh()"/> semantics.
+    /// recommended to consult the documentation of <see cref="ReferenceManager{G}"/>
+    /// implementations for their <see cref="MaybeRefresh()"/> semantics.
+    /// <para/>
+    /// @lucene.experimental
     /// </summary>
-    /// @param <G>
-    ///          the concrete type that will be <seealso cref="#acquire() acquired"/> and
-    ///          <seealso cref="#release(Object) released"/>.
-    ///
-    /// @lucene.experimental </param>
+    /// <typeparam name="G">The concrete type that will be <see cref="Acquire()"/>d and
+    ///          <see cref="Release(G)"/>d.</typeparam>
 #if FEATURE_SERIALIZABLE
     [Serializable]
 #endif
@@ -49,6 +48,9 @@ namespace Lucene.Net.Search
         // fields are not CLS compliant
         private volatile G current;
 
+        /// <summary>
+        /// The current reference
+        /// </summary>
         protected G Current
         {
             get { return current; }
@@ -80,29 +82,28 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Decrement reference counting on the given reference. </summary>
-        /// <exception cref="IOException"> if reference decrement on the given resource failed.
-        ///  </exception>
+        /// <exception cref="System.IO.IOException"> If reference decrement on the given resource failed.</exception>
         protected abstract void DecRef(G reference);
 
         /// <summary>
-        /// Refresh the given reference if needed. Returns {@code null} if no refresh
+        /// Refresh the given reference if needed. Returns <c>null</c> if no refresh
         /// was needed, otherwise a new refreshed reference. </summary>
-        /// <exception cref="ObjectDisposedException"> if the reference manager has been <seealso cref="#close() closed"/>. </exception>
-        /// <exception cref="IOException"> if the refresh operation failed </exception>
+        /// <exception cref="ObjectDisposedException"> If the reference manager has been <see cref="Dispose()"/>d. </exception>
+        /// <exception cref="System.IO.IOException"> If the refresh operation failed </exception>
         protected abstract G RefreshIfNeeded(G referenceToRefresh);
 
         /// <summary>
-        /// Try to increment reference counting on the given reference. Return true if
+        /// Try to increment reference counting on the given reference. Returns <c>true</c> if
         /// the operation was successful. </summary>
-        /// <exception cref="ObjectDisposedException"> if the reference manager has been <seealso cref="#close() closed"/>.  </exception>
+        /// <exception cref="ObjectDisposedException"> if the reference manager has been <see cref="Dispose()"/>d.  </exception>
         protected abstract bool TryIncRef(G reference);
 
         /// <summary>
         /// Obtain the current reference. You must match every call to acquire with one
-        /// call to <seealso cref="#release"/>; it's best to do so in a finally clause, and set
-        /// the reference to {@code null} to prevent accidental usage after it has been
+        /// call to <see cref="Release(G)"/>; it's best to do so in a finally clause, and set
+        /// the reference to <c>null</c> to prevent accidental usage after it has been
         /// released. </summary>
-        /// <exception cref="ObjectDisposedException"> if the reference manager has been <seealso cref="#close() closed"/>.  </exception>
+        /// <exception cref="ObjectDisposedException"> If the reference manager has been <see cref="Dispose()"/>d.  </exception>
         public G Acquire()
         {
             G @ref;
@@ -135,25 +136,25 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// <p>
-        /// Closes this ReferenceManager to prevent future <seealso cref="#acquire() acquiring"/>. A
-        /// reference manager should be closed if the reference to the managed resource
-        /// should be disposed or the application using the <seealso cref="ReferenceManager"/>
+        /// <para>
+        /// Closes this ReferenceManager to prevent future <see cref="Acquire()"/>ing. A
+        /// reference manager should be disposed if the reference to the managed resource
+        /// should be disposed or the application using the <see cref="ReferenceManager{G}"/>
         /// is shutting down. The managed resource might not be released immediately,
-        /// if the <seealso cref="ReferenceManager"/> user is holding on to a previously
-        /// <seealso cref="#acquire() acquired"/> reference. The resource will be released once
-        /// when the last reference is <seealso cref="#release(Object) released"/>. Those
+        /// if the <see cref="ReferenceManager{G}"/> user is holding on to a previously
+        /// <see cref="Acquire()"/>d reference. The resource will be released once
+        /// when the last reference is <see cref="Release(G)"/>d. Those
         /// references can still be used as if the manager was still active.
-        /// </p>
-        /// <p>
-        /// Applications should not <seealso cref="#acquire() acquire"/> new references from this
-        /// manager once this method has been called. <seealso cref="#acquire() Acquiring"/> a
-        /// resource on a closed <seealso cref="ReferenceManager"/> will throw an
+        /// </para>
+        /// <para>
+        /// Applications should not <see cref="Acquire()"/> new references from this
+        /// manager once this method has been called. <see cref="Acquire()"/>ing a
+        /// resource on a disposed <see cref="ReferenceManager{G}"/> will throw an
         /// <seealso cref="ObjectDisposedException"/>.
-        /// </p>
+        /// </para>
         /// </summary>
-        /// <exception cref="IOException">
-        ///           if the underlying reader of the current reference could not be closed </exception>
+        /// <exception cref="System.IO.IOException">
+        ///           If the underlying reader of the current reference could not be disposed </exception>
         public void Dispose()
         {
             lock (this)
@@ -175,10 +176,10 @@ namespace Lucene.Net.Search
         protected abstract int GetRefCount(G reference);
 
         /// <summary>
-        ///  Called after close(), so subclass can free any resources. </summary>
-        ///  <exception cref="IOException"> if the after close operation in a sub-class throws an <seealso cref="IOException"/>
-        ///  </exception>
-        protected virtual void AfterClose()
+        /// Called after <see cref="Dispose()"/>, so subclass can free any resources. </summary>
+        /// <exception cref="System.IO.IOException"> if the after dispose operation in a sub-class throws an <see cref="System.IO.IOException"/>
+        /// </exception>
+        protected virtual void AfterClose() // LUCENENET TODO: API: Rename AfterDispose() ? Or perhaps just use dispose pattern.
         {
         }
 
@@ -230,24 +231,24 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// You must call this (or <seealso cref="#maybeRefreshBlocking()"/>), periodically, if
-        /// you want that <seealso cref="#acquire()"/> will return refreshed instances.
+        /// You must call this (or <see cref="MaybeRefreshBlocking()"/>), periodically, if
+        /// you want that <see cref="Acquire()"/> will return refreshed instances.
         ///
-        /// <p>
+        /// <para>
         /// <b>Threads</b>: it's fine for more than one thread to call this at once.
         /// Only the first thread will attempt the refresh; subsequent threads will see
         /// that another thread is already handling refresh and will return
         /// immediately. Note that this means if another thread is already refreshing
         /// then subsequent threads will return right away without waiting for the
         /// refresh to complete.
-        ///
-        /// <p>
-        /// If this method returns true it means the calling thread either refreshed or
-        /// that there were no changes to refresh. If it returns false it means another
+        /// </para>
+        /// <para>
+        /// If this method returns <c>true</c> it means the calling thread either refreshed or
+        /// that there were no changes to refresh. If it returns <c>false</c> it means another
         /// thread is currently refreshing.
-        /// </p> </summary>
-        /// <exception cref="IOException"> if refreshing the resource causes an <seealso cref="IOException"/> </exception>
-        /// <exception cref="ObjectDisposedException"> if the reference manager has been <seealso cref="#close() closed"/>.  </exception>
+        /// </para> </summary>
+        /// <exception cref="System.IO.IOException"> If refreshing the resource causes an <see cref="System.IO.IOException"/> </exception>
+        /// <exception cref="ObjectDisposedException"> If the reference manager has been <see cref="Dispose()"/>d.  </exception>
         public bool MaybeRefresh()
         {
             EnsureOpen();
@@ -270,17 +271,17 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// You must call this (or <seealso cref="#maybeRefresh()"/>), periodically, if you want
-        /// that <seealso cref="#acquire()"/> will return refreshed instances.
+        /// You must call this (or <see cref="MaybeRefresh()"/>), periodically, if you want
+        /// that <see cref="Acquire()"/> will return refreshed instances.
         ///
-        /// <p>
-        /// <b>Threads</b>: unlike <seealso cref="#maybeRefresh()"/>, if another thread is
+        /// <para/>
+        /// <b>Threads</b>: unlike <see cref="MaybeRefresh()"/>, if another thread is
         /// currently refreshing, this method blocks until that thread completes. It is
-        /// useful if you want to guarantee that the next call to <seealso cref="#acquire()"/>
+        /// useful if you want to guarantee that the next call to <see cref="Acquire()"/>
         /// will return a refreshed instance. Otherwise, consider using the
-        /// non-blocking <seealso cref="#maybeRefresh()"/>. </summary>
-        /// <exception cref="IOException"> if refreshing the resource causes an <seealso cref="IOException"/> </exception>
-        /// <exception cref="ObjectDisposedException"> if the reference manager has been <seealso cref="#close() closed"/>.  </exception>
+        /// non-blocking <see cref="MaybeRefresh()"/>. </summary>
+        /// <exception cref="System.IO.IOException"> If refreshing the resource causes an <see cref="System.IO.IOException"/> </exception>
+        /// <exception cref="ObjectDisposedException"> If the reference manager has been <see cref="Dispose()"/>d.  </exception>
         public void MaybeRefreshBlocking()
         {
             EnsureOpen();
@@ -299,18 +300,17 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Called after a refresh was attempted, regardless of
-        ///  whether a new reference was in fact created. </summary>
-        ///  <exception cref="IOException"> if a low level I/O exception occurs
-        ///  </exception>
+        /// whether a new reference was in fact created. </summary>
+        /// <exception cref="System.IO.IOException"> if a low level I/O exception occurs</exception>
         protected virtual void AfterMaybeRefresh()
         {
         }
 
         /// <summary>
-        /// Release the reference previously obtained via <seealso cref="#acquire()"/>.
-        /// <p>
-        /// <b>NOTE:</b> it's safe to call this after <seealso cref="#close()"/>. </summary>
-        /// <exception cref="IOException"> if the release operation on the given resource throws an <seealso cref="IOException"/> </exception>
+        /// Release the reference previously obtained via <see cref="Acquire()"/>.
+        /// <para/>
+        /// <b>NOTE:</b> it's safe to call this after <see cref="Dispose()"/>. </summary>
+        /// <exception cref="System.IO.IOException"> If the release operation on the given resource throws an <see cref="System.IO.IOException"/> </exception>
         public void Release(G reference)
         {
             Debug.Assert(reference != null);
@@ -346,7 +346,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Remove a listener added with <seealso cref="#addListener(RefreshListener)"/>.
+        /// Remove a listener added with <see cref="AddListener(ReferenceManager.IRefreshListener)"/>.
         /// </summary>
         public virtual void RemoveListener(ReferenceManager.IRefreshListener listener)
         {
@@ -358,12 +358,15 @@ namespace Lucene.Net.Search
         }
     }
 
-    // .NET Port: non-generic type to hold RefreshListener
+    /// <summary>
+    /// LUCENENET specific class used to provide static access to <see cref="ReferenceManager.IRefreshListener"/>
+    /// without having to specifiy the generic closing type of <see cref="ReferenceManager{G}"/>.
+    /// </summary>
     public static class ReferenceManager
     {
         /// <summary>
         /// Use to receive notification when a refresh has
-        ///  finished.  See <seealso cref="#addListener"/>.
+        /// finished.  See <see cref="ReferenceManager{G}.AddListener(IRefreshListener)"/>.
         /// </summary>
         public interface IRefreshListener
         {
@@ -373,8 +376,8 @@ namespace Lucene.Net.Search
 
             /// <summary>
             /// Called after the attempted refresh; if the refresh
-            /// did open a new reference then didRefresh will be true
-            /// and <seealso cref="#acquire()"/> is guaranteed to return the new
+            /// did open a new reference then didRefresh will be <c>true</c>
+            /// and <see cref="ReferenceManager{G}.Acquire()"/> is guaranteed to return the new
             /// reference.
             /// </summary>
             void AfterRefresh(bool didRefresh);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/RegexpQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/RegexpQuery.cs b/src/Lucene.Net/Search/RegexpQuery.cs
index fc4fc29..7981730 100644
--- a/src/Lucene.Net/Search/RegexpQuery.cs
+++ b/src/Lucene.Net/Search/RegexpQuery.cs
@@ -29,25 +29,26 @@ namespace Lucene.Net.Search
 
     /// <summary>
     /// A fast regular expression query based on the
-    /// <seealso cref="Lucene.Net.Util.Automaton"/> package.
-    /// <ul>
-    /// <li>Comparisons are <a
-    /// href="http://tusker.org/regex/regex_benchmark.html">fast</a>
-    /// <li>The term dictionary is enumerated in an intelligent way, to avoid
-    /// comparisons. See <seealso cref="AutomatonQuery"/> for more details.
-    /// </ul>
-    /// <p>
-    /// The supported syntax is documented in the <seealso cref="RegExp"/> class.
+    /// <see cref="Lucene.Net.Util.Automaton"/> package.
+    /// <list type="bullet">
+    ///     <item><description>Comparisons are <a
+    ///         href="http://tusker.org/regex/regex_benchmark.html">fast</a></description></item>
+    ///     <item><description>The term dictionary is enumerated in an intelligent way, to avoid
+    ///         comparisons. See <see cref="AutomatonQuery"/> for more details.</description></item>
+    /// </list>
+    /// <para>
+    /// The supported syntax is documented in the <see cref="RegExp"/> class.
     /// Note this might be different than other regular expression implementations.
     /// For some alternatives with different syntax, look under the sandbox.
-    /// </p>
-    /// <p>
+    /// </para>
+    /// <para>
     /// Note this query can be slow, as it needs to iterate over many terms. In order
-    /// to prevent extremely slow RegexpQueries, a Regexp term should not start with
-    /// the expression <code>.*</code>
+    /// to prevent extremely slow <see cref="RegexpQuery"/>s, a <see cref="RegExp"/> term should not start with
+    /// the expression <c>.*</c>
+    /// </para>
+    /// @lucene.experimental
     /// </summary>
-    /// <seealso cref= RegExp
-    /// @lucene.experimental </seealso>
+    /// <seealso cref="RegExp"/>
 #if FEATURE_SERIALIZABLE
     [Serializable]
 #endif
@@ -70,33 +71,33 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Constructs a query for terms matching <code>term</code>.
-        /// <p>
+        /// Constructs a query for terms matching <paramref name="term"/>.
+        /// <para>
         /// By default, all regular expression features are enabled.
-        /// </p>
+        /// </para>
         /// </summary>
-        /// <param name="term"> regular expression. </param>
+        /// <param name="term"> Regular expression. </param>
         public RegexpQuery(Term term)
             : this(term, RegExpSyntax.ALL)
         {
         }
 
         /// <summary>
-        /// Constructs a query for terms matching <code>term</code>.
+        /// Constructs a query for terms matching <paramref name="term"/>.
         /// </summary>
-        /// <param name="term"> regular expression. </param>
-        /// <param name="flags"> optional RegExp features from <see cref="RegExpSyntax"/> </param>
+        /// <param name="term"> Regular expression. </param>
+        /// <param name="flags"> Optional <see cref="RegExp"/> features from <see cref="RegExpSyntax"/> </param>
         public RegexpQuery(Term term, RegExpSyntax flags)
             : this(term, flags, defaultProvider)
         {
         }
 
         /// <summary>
-        /// Constructs a query for terms matching <code>term</code>.
+        /// Constructs a query for terms matching <paramref name="term"/>.
         /// </summary>
-        /// <param name="term"> regular expression. </param>
-        /// <param name="flags"> optional RegExp features from <see cref="RegExpSyntax"/> </param>
-        /// <param name="provider"> custom AutomatonProvider for named automata </param>
+        /// <param name="term"> Regular expression. </param>
+        /// <param name="flags"> Optional <see cref="RegExp"/> features from <see cref="RegExpSyntax"/> </param>
+        /// <param name="provider"> Custom <see cref="IAutomatonProvider"/> for named automata </param>
         public RegexpQuery(Term term, RegExpSyntax flags, IAutomatonProvider provider)
             : base(term, (new RegExp(term.Text(), flags)).ToAutomaton(provider))
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/ReqExclScorer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/ReqExclScorer.cs b/src/Lucene.Net/Search/ReqExclScorer.cs
index a5d3822..dac790c 100644
--- a/src/Lucene.Net/Search/ReqExclScorer.cs
+++ b/src/Lucene.Net/Search/ReqExclScorer.cs
@@ -21,11 +21,11 @@ namespace Lucene.Net.Search
      */
 
     /// <summary>
-    /// A Scorer for queries with a required subscorer
-    /// and an excluding (prohibited) sub DocIdSetIterator.
-    /// <br>
-    /// this <code>Scorer</code> implements <seealso cref="Scorer#advance(int)"/>,
-    /// and it uses the skipTo() on the given scorers.
+    /// A <see cref="Scorer"/> for queries with a required subscorer
+    /// and an excluding (prohibited) sub <see cref="DocIdSetIterator"/>.
+    /// <para/>
+    /// This <see cref="Scorer"/> implements <see cref="DocIdSetIterator.Advance(int)"/>,
+    /// and it uses the SkipTo() on the given scorers.
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -37,9 +37,9 @@ namespace Lucene.Net.Search
         private int doc = -1;
 
         /// <summary>
-        /// Construct a <code>ReqExclScorer</code>. </summary>
+        /// Construct a <see cref="ReqExclScorer"/>. </summary>
         /// <param name="reqScorer"> The scorer that must match, except where </param>
-        /// <param name="exclDisi"> indicates exclusion. </param>
+        /// <param name="exclDisi"> Indicates exclusion. </param>
         public ReqExclScorer(Scorer reqScorer, DocIdSetIterator exclDisi)
             : base(reqScorer.m_weight)
         {
@@ -68,15 +68,15 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Advance to non excluded doc.
-        /// <br>On entry:
-        /// <ul>
-        /// <li>reqScorer != null,
-        /// <li>exclScorer != null,
-        /// <li>reqScorer was advanced once via next() or skipTo()
-        ///      and reqScorer.doc() may still be excluded.
-        /// </ul>
+        /// <para/>On entry:
+        /// <list type="bullet">
+        /// <item><description>reqScorer != null,</description></item>
+        /// <item><description>exclScorer != null,</description></item>
+        /// <item><description>reqScorer was advanced once via Next() or SkipTo()
+        ///      and reqScorer.Doc may still be excluded.</description></item>
+        /// </list>
         /// Advances reqScorer a non excluded required doc, if any. </summary>
-        /// <returns> true iff there is a non excluded required doc. </returns>
+        /// <returns> <c>true</c> if there is a non excluded required doc. </returns>
         private int ToNonExcluded()
         {
             int exclDoc = exclDisi.DocID;
@@ -112,7 +112,7 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Returns the score of the current document matching the query.
-        /// Initially invalid, until <seealso cref="#nextDoc()"/> is called the first time. </summary>
+        /// Initially invalid, until <see cref="NextDoc()"/> is called the first time. </summary>
         /// <returns> The score of the required scorer. </returns>
         public override float GetScore()
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/ReqOptSumScorer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/ReqOptSumScorer.cs b/src/Lucene.Net/Search/ReqOptSumScorer.cs
index 679e5a7..af31188 100644
--- a/src/Lucene.Net/Search/ReqOptSumScorer.cs
+++ b/src/Lucene.Net/Search/ReqOptSumScorer.cs
@@ -22,10 +22,10 @@ namespace Lucene.Net.Search
      */
 
     /// <summary>
-    /// A Scorer for queries with a required part and an optional part.
-    /// Delays skipTo() on the optional part until a score() is needed.
-    /// <br>
-    /// this <code>Scorer</code> implements <seealso cref="Scorer#advance(int)"/>.
+    /// A <see cref="Scorer"/> for queries with a required part and an optional part.
+    /// Delays SkipTo() on the optional part until a GetScore() is needed.
+    /// <para/>
+    /// This <see cref="Scorer"/> implements <see cref="DocIdSetIterator.Advance(int)"/>.
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -34,16 +34,16 @@ namespace Lucene.Net.Search
     {
         /// <summary>
         /// The scorers passed from the constructor.
-        /// These are set to null as soon as their next() or skipTo() returns false.
+        /// These are set to <c>null</c> as soon as their Next() or SkipTo() returns <c>false</c>.
         /// </summary>
         private Scorer reqScorer;
 
         private Scorer optScorer;
 
         /// <summary>
-        /// Construct a <code>ReqOptScorer</code>. </summary>
-        /// <param name="reqScorer"> The required scorer. this must match. </param>
-        /// <param name="optScorer"> The optional scorer. this is used for scoring only. </param>
+        /// Construct a <see cref="ReqOptSumScorer"/>. </summary>
+        /// <param name="reqScorer"> The required scorer. This must match. </param>
+        /// <param name="optScorer"> The optional scorer. This is used for scoring only. </param>
         public ReqOptSumScorer(Scorer reqScorer, Scorer optScorer)
             : base(reqScorer.m_weight)
         {
@@ -70,7 +70,7 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Returns the score of the current document matching the query.
-        /// Initially invalid, until <seealso cref="#nextDoc()"/> is called the first time. </summary>
+        /// Initially invalid, until <see cref="NextDoc()"/> is called the first time. </summary>
         /// <returns> The score of the required scorer, eventually increased by the score
         /// of the optional scorer when it also matches the current document. </returns>
         public override float GetScore()


Mime
View raw message