Cleaning up XML doc comments.

Rx.NET/Source/src/Microsoft.Reactive.Testing/Recorded.cs

@@ -54,32 +54,32 @@ namespace Microsoft.Reactive.Testing
         }
 
         /// <summary>
-        /// Determines whether the two specified Recorded&lt;T&gt; values have the same Time and Value.
+        /// Determines whether the two specified <see cref="Recorded{T}"/> values have the same Time and Value.
         /// </summary>
-        /// <param name="left">The first Recorded&lt;T&gt; value to compare.</param>
-        /// <param name="right">The second Recorded&lt;T&gt; value to compare.</param>
-        /// <returns>true if the first Recorded&lt;T&gt; value has the same Time and Value as the second Recorded&lt;T&gt; value; otherwise, false.</returns>
+        /// <param name="left">The first <see cref="Recorded{T}"/> value to compare.</param>
+        /// <param name="right">The second <see cref="Recorded{T}"/> value to compare.</param>
+        /// <returns>true if the first <see cref="Recorded{T}"/> value has the same Time and Value as the second <see cref="Recorded{T}"/> value; otherwise, false.</returns>
         public static bool operator ==(Recorded<T> left, Recorded<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>
-        /// Determines whether the two specified Recorded&lt;T&gt; values don't have the same Time and Value.
+        /// Determines whether the two specified <see cref="Recorded{T}"/> values don't have the same Time and Value.
         /// </summary>
-        /// <param name="left">The first Recorded&lt;T&gt; value to compare.</param>
-        /// <param name="right">The second Recorded&lt;T&gt; value to compare.</param>
-        /// <returns>true if the first Recorded&lt;T&gt; value has a different Time or Value as the second Recorded&lt;T&gt; value; otherwise, false.</returns>
+        /// <param name="left">The first <see cref="Recorded{T}"/> value to compare.</param>
+        /// <param name="right">The second <see cref="Recorded{T}"/> value to compare.</param>
+        /// <returns>true if the first <see cref="Recorded{T}"/> value has a different Time or Value as the second <see cref="Recorded{T}"/> value; otherwise, false.</returns>
         public static bool operator !=(Recorded<T> left, Recorded<T> right)
         {
             return !left.Equals(right);
         }
 
         /// <summary>
-        /// Determines whether the specified System.Object is equal to the current Recorded&lt;T&gt; value.
+        /// Determines whether the specified System.Object is equal to the current <see cref="Recorded{T}"/> value.
         /// </summary>
-        /// <param name="obj">The System.Object to compare with the current Recorded&lt;T&gt; value.</param>
-        /// <returns>true if the specified System.Object is equal to the current Recorded&lt;T&gt; value; otherwise, false.</returns>
+        /// <param name="obj">The System.Object to compare with the current <see cref="Recorded{T}"/> value.</param>
+        /// <returns>true if the specified System.Object is equal to the current <see cref="Recorded{T}"/> value; otherwise, false.</returns>
         public override bool Equals(object obj)
         {
             if (obj is Recorded<T>)
@@ -88,18 +88,18 @@ namespace Microsoft.Reactive.Testing
         }
 
         /// <summary>
-        /// Returns the hash code for the current Recorded&lt;T&gt; value.
+        /// Returns the hash code for the current <see cref="Recorded{T}"/> value.
         /// </summary>
-        /// <returns>A hash code for the current Recorded&lt;T&gt; value.</returns>
+        /// <returns>A hash code for the current <see cref="Recorded{T}"/> value.</returns>
         public override int GetHashCode()
         {
             return Time.GetHashCode() + EqualityComparer<T>.Default.GetHashCode(Value);
         }
 
         /// <summary>
-        /// Returns a string representation of the current Recorded&lt;T&gt; value.
+        /// Returns a string representation of the current <see cref="Recorded{T}"/> value.
         /// </summary>
-        /// <returns>String representation of the current Recorded&lt;T&gt; value.</returns>
+        /// <returns>String representation of the current <see cref="Recorded{T}"/> value.</returns>
         public override string ToString()
         {
             return Value.ToString() + "@" + Time.ToString(CultureInfo.CurrentCulture);

Rx.NET/Source/src/System.Reactive.Observable.Aliases/Observable.Aliases.cs

@@ -326,7 +326,7 @@ namespace System.Reactive.Observable.Aliases
         /// <param name="selector">A transform function to apply to each element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Linq.Observable.ToObservable&lt;TSource&gt;(IEnumerable&lt;TSource&gt;)"/> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Linq.Observable.ToObservable{TSource}(IEnumerable{TSource})"/> conversion.</remarks>
         public static IObservable<TResult> FlatMap<TSource, TResult>(this IObservable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
         {
             return source.SelectMany<TSource, TResult>(selector);
@@ -342,7 +342,7 @@ namespace System.Reactive.Observable.Aliases
         /// <param name="selector">A transform function to apply to each element; the second parameter of the function represents the index of the source element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Linq.Observable.ToObservable&lt;TSource&gt;(IEnumerable&lt;TSource&gt;)"/> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Linq.Observable.ToObservable{TSource}(IEnumerable{TSource})"/> conversion.</remarks>
         public static IObservable<TResult> FlatMap<TSource, TResult>(this IObservable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
         {
             return source.SelectMany<TSource, TResult>(selector);
@@ -360,7 +360,7 @@ namespace System.Reactive.Observable.Aliases
         /// <param name="resultSelector">A transform function to apply to each element of the intermediate sequence.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="collectionSelector"/> or <paramref name="resultSelector"/> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Linq.Observable.ToObservable&lt;TSource&gt;(IEnumerable&lt;TSource&gt;)"/> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Linq.Observable.ToObservable{TSource}(IEnumerable{TSource})"/> conversion.</remarks>
         public static IObservable<TResult> FlatMap<TSource, TCollection, TResult>(this IObservable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
         {
             return source.SelectMany<TSource, TCollection, TResult>(collectionSelector, resultSelector);
@@ -378,7 +378,7 @@ namespace System.Reactive.Observable.Aliases
         /// <param name="resultSelector">A transform function to apply to each element of the intermediate sequence; the second parameter of the function represents the index of the source element and the fourth parameter represents the index of the intermediate element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="collectionSelector"/> or <paramref name="resultSelector"/> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Linq.Observable.ToObservable&lt;TSource&gt;(IEnumerable&lt;TSource&gt;)"/> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Linq.Observable.ToObservable{TSource}(IEnumerable{TSource})"/> conversion.</remarks>
         public static IObservable<TResult> FlatMap<TSource, TCollection, TResult>(this IObservable<TSource> source, Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, int, TCollection, int, TResult> resultSelector)
         {
             return source.SelectMany<TSource, TCollection, TResult>(collectionSelector, resultSelector);

Rx.NET/Source/src/System.Reactive.Observable.Aliases/Qbservable.Aliases.Generated.cs

@@ -38,7 +38,7 @@ namespace System.Reactive.Linq
         /// <param name="source">An observable sequence whose elements to filter.</param>
         /// <param name="predicate">A function to test each source element for a condition.</param>
         /// <returns>An observable sequence that contains elements from the input sequence that satisfy the condition.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="predicate" /> is null.</exception>
         public static IQbservable<TSource> Filter<TSource>(this IQbservable<TSource> source, Expression<Func<TSource, bool>> predicate)
         {
@@ -53,7 +53,7 @@ namespace System.Reactive.Linq
         /// <param name="source">An observable sequence whose elements to filter.</param>
         /// <param name="predicate">A function to test each source element for a conditio; the second parameter of the function represents the index of the source element.</param>
         /// <returns>An observable sequence that contains elements from the input sequence that satisfy the condition.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="predicate" /> is null.</exception>
         public static IQbservable<TSource> Filter<TSource>(this IQbservable<TSource> source, Expression<Func<TSource, int, bool>> predicate)
         {
@@ -71,7 +71,7 @@ namespace System.Reactive.Linq
         /// <param name="collectionSelector">A transform function to apply to each element.</param>
         /// <param name="resultSelector">A transform function to apply to each element of the intermediate sequence.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="collectionSelector" /> or <paramref name="resultSelector" /> is null.</exception>
         public static IQbservable<TResult> FlatMap<TSource, TCollection, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, IObservable<TCollection>>> collectionSelector, Expression<Func<TSource, TCollection, TResult>> resultSelector)
         {
@@ -89,7 +89,7 @@ namespace System.Reactive.Linq
         /// <param name="collectionSelector">A transform function to apply to each element; the second parameter of the function represents the index of the source element.</param>
         /// <param name="resultSelector">A transform function to apply to each element of the intermediate sequence; the second parameter of the function represents the index of the source element and the fourth parameter represents the index of the intermediate element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="collectionSelector" /> or <paramref name="resultSelector" /> is null.</exception>
         public static IQbservable<TResult> FlatMap<TSource, TCollection, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, int, IObservable<TCollection>>> collectionSelector, Expression<Func<TSource, int, TCollection, int, TResult>> resultSelector)
         {
@@ -107,9 +107,9 @@ namespace System.Reactive.Linq
         /// <param name="collectionSelector">A transform function to apply to each element.</param>
         /// <param name="resultSelector">A transform function to apply to each element of the intermediate sequence.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="collectionSelector" /> or <paramref name="resultSelector" /> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="M:System.Reactive.Linq.Observable.ToObservable``1(System.Collections.Generic.IEnumerable{``0})" /> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})" /> conversion.</remarks>
         public static IQbservable<TResult> FlatMap<TSource, TCollection, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, IEnumerable<TCollection>>> collectionSelector, Expression<Func<TSource, TCollection, TResult>> resultSelector)
         {
             return Qbservable.SelectMany<TSource, TCollection, TResult>(source, collectionSelector, resultSelector);
@@ -126,9 +126,9 @@ namespace System.Reactive.Linq
         /// <param name="collectionSelector">A transform function to apply to each element; the second parameter of the function represents the index of the source element.</param>
         /// <param name="resultSelector">A transform function to apply to each element of the intermediate sequence; the second parameter of the function represents the index of the source element and the fourth parameter represents the index of the intermediate element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="collectionSelector" /> or <paramref name="resultSelector" /> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="M:System.Reactive.Linq.Observable.ToObservable``1(System.Collections.Generic.IEnumerable{``0})" /> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})" /> conversion.</remarks>
         public static IQbservable<TResult> FlatMap<TSource, TCollection, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, int, IEnumerable<TCollection>>> collectionSelector, Expression<Func<TSource, int, TCollection, int, TResult>> resultSelector)
         {
             return Qbservable.SelectMany<TSource, TCollection, TResult>(source, collectionSelector, resultSelector);
@@ -143,7 +143,7 @@ namespace System.Reactive.Linq
         /// <param name="source">An observable sequence of elements to project.</param>
         /// <param name="other">An observable sequence to project each element from the source sequence onto.</param>
         /// <returns>An observable sequence whose elements are the result of projecting each source element onto the other sequence and merging all the resulting sequences together.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="other" /> is null.</exception>
         public static IQbservable<TOther> FlatMap<TSource, TOther>(this IQbservable<TSource> source, IObservable<TOther> other)
         {
@@ -161,7 +161,7 @@ namespace System.Reactive.Linq
         /// <param name="onError">A transform function to apply when an error occurs in the source sequence.</param>
         /// <param name="onCompleted">A transform function to apply when the end of the source sequence is reached.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="onNext" /> or <paramref name="onError" /> or <paramref name="onCompleted" /> is null.</exception>
         public static IQbservable<TResult> FlatMap<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, IObservable<TResult>>> onNext, Expression<Func<Exception, IObservable<TResult>>> onError, Expression<Func<IObservable<TResult>>> onCompleted)
         {
@@ -179,7 +179,7 @@ namespace System.Reactive.Linq
         /// <param name="onError">A transform function to apply when an error occurs in the source sequence.</param>
         /// <param name="onCompleted">A transform function to apply when the end of the source sequence is reached.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="onNext" /> or <paramref name="onError" /> or <paramref name="onCompleted" /> is null.</exception>
         public static IQbservable<TResult> FlatMap<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, int, IObservable<TResult>>> onNext, Expression<Func<Exception, IObservable<TResult>>> onError, Expression<Func<IObservable<TResult>>> onCompleted)
         {
@@ -195,7 +195,7 @@ namespace System.Reactive.Linq
         /// <param name="source">An observable sequence of elements to project.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         public static IQbservable<TResult> FlatMap<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, IObservable<TResult>>> selector)
         {
@@ -211,7 +211,7 @@ namespace System.Reactive.Linq
         /// <param name="source">An observable sequence of elements to project.</param>
         /// <param name="selector">A transform function to apply to each element; the second parameter of the function represents the index of the source element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         public static IQbservable<TResult> FlatMap<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, int, IObservable<TResult>>> selector)
         {
@@ -228,8 +228,8 @@ namespace System.Reactive.Linq
         /// <param name="source">An observable sequence of elements to project.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
         /// <returns>An observable sequence whose elements are the result of the tasks executed for each element of the input sequence.</returns>
-        /// <remarks>This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using <see cref="M:System.Reactive.Threading.Tasks.TaskObservableExtensions.ToObservable``1(System.Threading.Tasks.Task{``0})" />.</remarks>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <remarks>This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using <see cref="Reactive.Threading.Tasks.TaskObservableExtensions.ToObservable{TSource}(Task{TSource})" />.</remarks>
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         public static IQbservable<TResult> FlatMap<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, Task<TResult>>> selector)
         {
@@ -247,8 +247,8 @@ namespace System.Reactive.Linq
         /// <param name="source">An observable sequence of elements to project.</param>
         /// <param name="selector">A transform function to apply to each element; the second parameter of the function represents the index of the source element.</param>
         /// <returns>An observable sequence whose elements are the result of the tasks executed for each element of the input sequence.</returns>
-        /// <remarks>This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using <see cref="M:System.Reactive.Threading.Tasks.TaskObservableExtensions.ToObservable``1(System.Threading.Tasks.Task{``0})" />.</remarks>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <remarks>This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using <see cref="Reactive.Threading.Tasks.TaskObservableExtensions.ToObservable{TSource}(Task{TSource})" />.</remarks>
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         public static IQbservable<TResult> FlatMap<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, int, Task<TResult>>> selector)
         {
@@ -266,8 +266,8 @@ namespace System.Reactive.Linq
         /// <param name="source">An observable sequence of elements to project.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
         /// <returns>An observable sequence whose elements are the result of the tasks executed for each element of the input sequence.</returns>
-        /// <remarks>This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using <see cref="M:System.Reactive.Threading.Tasks.TaskObservableExtensions.ToObservable``1(System.Threading.Tasks.Task{``0})" />.</remarks>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <remarks>This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using <see cref="Reactive.Threading.Tasks.TaskObservableExtensions.ToObservable{TSource}(Task{TSource})" />.</remarks>
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         public static IQbservable<TResult> FlatMap<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, CancellationToken, Task<TResult>>> selector)
         {
@@ -285,8 +285,8 @@ namespace System.Reactive.Linq
         /// <param name="source">An observable sequence of elements to project.</param>
         /// <param name="selector">A transform function to apply to each element; the second parameter of the function represents the index of the source element.</param>
         /// <returns>An observable sequence whose elements are the result of the tasks executed for each element of the input sequence.</returns>
-        /// <remarks>This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using <see cref="M:System.Reactive.Threading.Tasks.TaskObservableExtensions.ToObservable``1(System.Threading.Tasks.Task{``0})" />.</remarks>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <remarks>This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using <see cref="Reactive.Threading.Tasks.TaskObservableExtensions.ToObservable{TSource}(Task{TSource})" />.</remarks>
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         public static IQbservable<TResult> FlatMap<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, int, CancellationToken, Task<TResult>>> selector)
         {
@@ -303,9 +303,9 @@ namespace System.Reactive.Linq
         /// <param name="source">An observable sequence of elements to project.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="M:System.Reactive.Linq.Observable.ToObservable``1(System.Collections.Generic.IEnumerable{``0})" /> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})" /> conversion.</remarks>
         public static IQbservable<TResult> FlatMap<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, IEnumerable<TResult>>> selector)
         {
             return Qbservable.SelectMany<TSource, TResult>(source, selector);
@@ -320,9 +320,9 @@ namespace System.Reactive.Linq
         /// <param name="source">An observable sequence of elements to project.</param>
         /// <param name="selector">A transform function to apply to each element; the second parameter of the function represents the index of the source element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="M:System.Reactive.Linq.Observable.ToObservable``1(System.Collections.Generic.IEnumerable{``0})" /> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})" /> conversion.</remarks>
         public static IQbservable<TResult> FlatMap<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, int, IEnumerable<TResult>>> selector)
         {
             return Qbservable.SelectMany<TSource, TResult>(source, selector);
@@ -340,9 +340,9 @@ namespace System.Reactive.Linq
         /// <param name="taskSelector">A transform function to apply to each element.</param>
         /// <param name="resultSelector">A transform function to apply to each element of the intermediate sequence.</param>
         /// <returns>An observable sequence whose elements are the result of obtaining a task for each element of the input sequence and then mapping the task's result and its corresponding source element to a result element.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="taskSelector" /> or <paramref name="resultSelector" /> is null.</exception>
-        /// <remarks>This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using <see cref="M:System.Reactive.Threading.Tasks.TaskObservableExtensions.ToObservable``1(System.Threading.Tasks.Task{``0})" />.</remarks>
+        /// <remarks>This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using <see cref="Reactive.Threading.Tasks.TaskObservableExtensions.ToObservable{TSource}(Task{TSource})" />.</remarks>
         public static IQbservable<TResult> FlatMap<TSource, TTaskResult, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, Task<TTaskResult>>> taskSelector, Expression<Func<TSource, TTaskResult, TResult>> resultSelector)
         {
             return Qbservable.SelectMany<TSource, TTaskResult, TResult>(source, taskSelector, resultSelector);
@@ -361,9 +361,9 @@ namespace System.Reactive.Linq
         /// <param name="taskSelector">A transform function to apply to each element; the second parameter of the function represents the index of the source element.</param>
         /// <param name="resultSelector">A transform function to apply to each element of the intermediate sequence; the second parameter of the function represents the index of the source element.</param>
         /// <returns>An observable sequence whose elements are the result of obtaining a task for each element of the input sequence and then mapping the task's result and its corresponding source element to a result element.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="taskSelector" /> or <paramref name="resultSelector" /> is null.</exception>
-        /// <remarks>This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using <see cref="M:System.Reactive.Threading.Tasks.TaskObservableExtensions.ToObservable``1(System.Threading.Tasks.Task{``0})" />.</remarks>
+        /// <remarks>This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using <see cref="Reactive.Threading.Tasks.TaskObservableExtensions.ToObservable{TSource}(Task{TSource})" />.</remarks>
         public static IQbservable<TResult> FlatMap<TSource, TTaskResult, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, int, Task<TTaskResult>>> taskSelector, Expression<Func<TSource, int, TTaskResult, TResult>> resultSelector)
         {
             return Qbservable.SelectMany<TSource, TTaskResult, TResult>(source, taskSelector, resultSelector);
@@ -382,9 +382,9 @@ namespace System.Reactive.Linq
         /// <param name="taskSelector">A transform function to apply to each element.</param>
         /// <param name="resultSelector">A transform function to apply to each element of the intermediate sequence.</param>
         /// <returns>An observable sequence whose elements are the result of obtaining a task for each element of the input sequence and then mapping the task's result and its corresponding source element to a result element.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="taskSelector" /> or <paramref name="resultSelector" /> is null.</exception>
-        /// <remarks>This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using <see cref="M:System.Reactive.Threading.Tasks.TaskObservableExtensions.ToObservable``1(System.Threading.Tasks.Task{``0})" />.</remarks>
+        /// <remarks>This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using <see cref="Reactive.Threading.Tasks.TaskObservableExtensions.ToObservable{TSource}(Task{TSource})" />.</remarks>
         public static IQbservable<TResult> FlatMap<TSource, TTaskResult, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, CancellationToken, Task<TTaskResult>>> taskSelector, Expression<Func<TSource, TTaskResult, TResult>> resultSelector)
         {
             return Qbservable.SelectMany<TSource, TTaskResult, TResult>(source, taskSelector, resultSelector);
@@ -403,9 +403,9 @@ namespace System.Reactive.Linq
         /// <param name="taskSelector">A transform function to apply to each element; the second parameter of the function represents the index of the source element.</param>
         /// <param name="resultSelector">A transform function to apply to each element of the intermediate sequence; the second parameter of the function represents the index of the source element.</param>
         /// <returns>An observable sequence whose elements are the result of obtaining a task for each element of the input sequence and then mapping the task's result and its corresponding source element to a result element.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="taskSelector" /> or <paramref name="resultSelector" /> is null.</exception>
-        /// <remarks>This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using <see cref="M:System.Reactive.Threading.Tasks.TaskObservableExtensions.ToObservable``1(System.Threading.Tasks.Task{``0})" />.</remarks>
+        /// <remarks>This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using <see cref="Reactive.Threading.Tasks.TaskObservableExtensions.ToObservable{TSource}(Task{TSource})" />.</remarks>
         public static IQbservable<TResult> FlatMap<TSource, TTaskResult, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, int, CancellationToken, Task<TTaskResult>>> taskSelector, Expression<Func<TSource, int, TTaskResult, TResult>> resultSelector)
         {
             return Qbservable.SelectMany<TSource, TTaskResult, TResult>(source, taskSelector, resultSelector);
@@ -420,7 +420,7 @@ namespace System.Reactive.Linq
         /// <param name="source">A sequence of elements to invoke a transform function on.</param>
         /// <param name="selector">A transform function to apply to each source element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the transform function on each element of source.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         public static IQbservable<TResult> Map<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, TResult>> selector)
         {
@@ -435,7 +435,7 @@ namespace System.Reactive.Linq
         /// <param name="source">A sequence of elements to invoke a transform function on.</param>
         /// <param name="selector">A transform function to apply to each source element; the second parameter of the function represents the index of the source element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the transform function on each element of source.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         public static IQbservable<TResult> Map<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, int, TResult>> selector)
         {

Rx.NET/Source/src/System.Reactive/AnonymousObservable.cs

@@ -7,7 +7,7 @@ using System.Reactive.Disposables;
 namespace System.Reactive
 {
     /// <summary>
-    /// Class to create an IObservable&lt;T&gt; instance from a delegate-based implementation of the Subscribe method.
+    /// Class to create an <see cref="IObservable{T}"/> instance from a delegate-based implementation of the Subscribe method.
     /// </summary>
     /// <typeparam name="T">The type of the elements in the sequence.</typeparam>
     public sealed class AnonymousObservable<T> : ObservableBase<T>

Rx.NET/Source/src/System.Reactive/AnonymousObserver.cs

@@ -5,7 +5,7 @@
 namespace System.Reactive
 {
     /// <summary>
-    /// Class to create an IObserver&lt;T&gt; instance from delegate-based implementations of the On* methods.
+    /// Class to create an <see cref="IObserver{T}"/> instance from delegate-based implementations of the On* methods.
     /// </summary>
     /// <typeparam name="T">The type of the elements in the sequence.</typeparam>
     public sealed class AnonymousObserver<T> : ObserverBase<T>

Rx.NET/Source/src/System.Reactive/Concurrency/ScheduledItem.cs

@@ -74,7 +74,7 @@ namespace System.Reactive.Concurrency
         }
 
         /// <summary>
-        /// Determines whether one specified ScheduledItem&lt;TAbsolute&gt; object is due before a second specified ScheduledItem&lt;TAbsolute&gt; object.
+        /// Determines whether one specified <see cref="ScheduledItem{TAbsolute}" /> object is due before a second specified <see cref="ScheduledItem{TAbsolute}" /> object.
         /// </summary>
         /// <param name="left">The first object to compare.</param>
         /// <param name="right">The second object to compare.</param>
@@ -86,7 +86,7 @@ namespace System.Reactive.Concurrency
         }
 
         /// <summary>
-        /// Determines whether one specified ScheduledItem&lt;TAbsolute&gt; object is due before or at the same of a second specified ScheduledItem&lt;TAbsolute&gt; object.
+        /// Determines whether one specified <see cref="ScheduledItem{TAbsolute}" /> object is due before or at the same of a second specified <see cref="ScheduledItem{TAbsolute}" /> object.
         /// </summary>
         /// <param name="left">The first object to compare.</param>
         /// <param name="right">The second object to compare.</param>
@@ -98,7 +98,7 @@ namespace System.Reactive.Concurrency
         }
 
         /// <summary>
-        /// Determines whether one specified ScheduledItem&lt;TAbsolute&gt; object is due after a second specified ScheduledItem&lt;TAbsolute&gt; object.
+        /// Determines whether one specified <see cref="ScheduledItem{TAbsolute}" /> object is due after a second specified <see cref="ScheduledItem{TAbsolute}" /> object.
         /// </summary>
         /// <param name="left">The first object to compare.</param>
         /// <param name="right">The second object to compare.</param>
@@ -110,7 +110,7 @@ namespace System.Reactive.Concurrency
         }
 
         /// <summary>
-        /// Determines whether one specified ScheduledItem&lt;TAbsolute&gt; object is due after or at the same time of a second specified ScheduledItem&lt;TAbsolute&gt; object.
+        /// Determines whether one specified <see cref="ScheduledItem{TAbsolute}" /> object is due after or at the same time of a second specified <see cref="ScheduledItem{TAbsolute}" /> object.
         /// </summary>
         /// <param name="left">The first object to compare.</param>
         /// <param name="right">The second object to compare.</param>
@@ -126,11 +126,11 @@ namespace System.Reactive.Concurrency
         #region Equality
 
         /// <summary>
-        /// Determines whether two specified ScheduledItem&lt;TAbsolute, TValue&gt; objects are equal.
+        /// Determines whether two specified <see cref="ScheduledItem{TAbsolute, TValue}" /> objects are equal.
         /// </summary>
         /// <param name="left">The first object to compare.</param>
         /// <param name="right">The second object to compare.</param>
-        /// <returns>true if both ScheduledItem&lt;TAbsolute, TValue&gt; are equal; otherwise, false.</returns>
+        /// <returns>true if both <see cref="ScheduledItem{TAbsolute, TValue}" /> are equal; otherwise, false.</returns>
         /// <remarks>This operator does not provide results consistent with the IComparable implementation. Instead, it implements reference equality.</remarks>
         public static bool operator ==(ScheduledItem<TAbsolute> left, ScheduledItem<TAbsolute> right)
         {
@@ -138,11 +138,11 @@ namespace System.Reactive.Concurrency
         }
 
         /// <summary>
-        /// Determines whether two specified ScheduledItem&lt;TAbsolute, TValue&gt; objects are inequal.
+        /// Determines whether two specified <see cref="ScheduledItem{TAbsolute, TValue}" /> objects are inequal.
         /// </summary>
         /// <param name="left">The first object to compare.</param>
         /// <param name="right">The second object to compare.</param>
-        /// <returns>true if both ScheduledItem&lt;TAbsolute, TValue&gt; are inequal; otherwise, false.</returns>
+        /// <returns>true if both <see cref="ScheduledItem{TAbsolute, TValue}" /> are inequal; otherwise, false.</returns>
         /// <remarks>This operator does not provide results consistent with the IComparable implementation. Instead, it implements reference equality.</remarks>
         public static bool operator !=(ScheduledItem<TAbsolute> left, ScheduledItem<TAbsolute> right)
         {
@@ -150,17 +150,17 @@ namespace System.Reactive.Concurrency
         }
 
         /// <summary>
-        /// Determines whether a ScheduledItem&lt;TAbsolute&gt; object is equal to the specified object.
+        /// Determines whether a <see cref="ScheduledItem{TAbsolute}" /> object is equal to the specified object.
         /// </summary>
-        /// <param name="obj">The object to compare to the current ScheduledItem&lt;TAbsolute&gt; object.</param>
-        /// <returns>true if the obj parameter is a ScheduledItem&lt;TAbsolute&gt; object and is equal to the current ScheduledItem&lt;TAbsolute&gt; object; otherwise, false.</returns>
+        /// <param name="obj">The object to compare to the current <see cref="ScheduledItem{TAbsolute}" /> object.</param>
+        /// <returns>true if the obj parameter is a <see cref="ScheduledItem{TAbsolute}" /> object and is equal to the current <see cref="ScheduledItem{TAbsolute}" /> object; otherwise, false.</returns>
         public override bool Equals(object obj)
         {
             return object.ReferenceEquals(this, obj);
         }
 
         /// <summary>
-        /// Returns the hash code for the current ScheduledItem&lt;TAbsolute&gt; object.
+        /// Returns the hash code for the current <see cref="ScheduledItem{TAbsolute}" /> object.
         /// </summary>
         /// <returns>A 32-bit signed integer hash code.</returns>
         public override int GetHashCode()

Rx.NET/Source/src/System.Reactive/Concurrency/SynchronizationContextScheduler.cs

@@ -9,7 +9,7 @@ using System.Threading;
 namespace System.Reactive.Concurrency
 {
     /// <summary>
-    /// Represents an object that schedules units of work on a provided <seealso cref="T:System.Threading.SynchronizationContext"/>.
+    /// Represents an object that schedules units of work on a provided <seealso cref="SynchronizationContext"/>.
     /// </summary>
     public class SynchronizationContextScheduler : LocalScheduler
     {
@@ -17,7 +17,7 @@ namespace System.Reactive.Concurrency
         private readonly bool _alwaysPost;
 
         /// <summary>
-        /// Creates an object that schedules units of work on the provided <see cref="T:System.Threading.SynchronizationContext"/>.
+        /// Creates an object that schedules units of work on the provided <see cref="SynchronizationContext"/>.
         /// </summary>
         /// <param name="context">Synchronization context to schedule units of work on.</param>
         /// <exception cref="ArgumentNullException"><paramref name="context"/> is null.</exception>
@@ -31,7 +31,7 @@ namespace System.Reactive.Concurrency
         }
 
         /// <summary>
-        /// Creates an object that schedules units of work on the provided <see cref="T:System.Threading.SynchronizationContext"/>.
+        /// Creates an object that schedules units of work on the provided <see cref="SynchronizationContext"/>.
         /// </summary>
         /// <param name="context">Synchronization context to schedule units of work on.</param>
         /// <param name="alwaysPost">Configures whether scheduling always posts to the synchronization context, regardless whether the caller is on the same synchronization context.</param>

Rx.NET/Source/src/System.Reactive/Disposables/BooleanDisposable.cs

@@ -17,7 +17,7 @@ namespace System.Reactive.Disposables
         private volatile bool _isDisposed;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="T:System.Reactive.Disposables.BooleanDisposable"/> class.
+        /// Initializes a new instance of the <see cref="BooleanDisposable"/> class.
         /// </summary>
         public BooleanDisposable()
         {

Rx.NET/Source/src/System.Reactive/Disposables/CancellationDisposable.cs

@@ -8,16 +8,16 @@ using System.Threading;
 namespace System.Reactive.Disposables
 {
     /// <summary>
-    /// Represents a disposable resource that has an associated <seealso cref="T:System.Threading.CancellationToken"/> that will be set to the cancellation requested state upon disposal.
+    /// Represents a disposable resource that has an associated <seealso cref="CancellationToken"/> that will be set to the cancellation requested state upon disposal.
     /// </summary>
     public sealed class CancellationDisposable : ICancelable
     {
         private readonly CancellationTokenSource _cts;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="T:System.Reactive.Disposables.CancellationDisposable"/> class that uses an existing <seealso cref="T:System.Threading.CancellationTokenSource"/>.
+        /// Initializes a new instance of the <see cref="CancellationDisposable"/> class that uses an existing <seealso cref="CancellationTokenSource"/>.
         /// </summary>
-        /// <param name="cts"><seealso cref="T:System.Threading.CancellationTokenSource"/> used for cancellation.</param>
+        /// <param name="cts"><seealso cref="CancellationTokenSource"/> used for cancellation.</param>
         /// <exception cref="ArgumentNullException"><paramref name="cts"/> is null.</exception>
         public CancellationDisposable(CancellationTokenSource cts)
         {
@@ -28,7 +28,7 @@ namespace System.Reactive.Disposables
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="T:System.Reactive.Disposables.CancellationDisposable"/> class that uses a new <seealso cref="T:System.Threading.CancellationTokenSource"/>.
+        /// Initializes a new instance of the <see cref="CancellationDisposable"/> class that uses a new <seealso cref="CancellationTokenSource"/>.
         /// </summary>
         public CancellationDisposable()
             : this(new CancellationTokenSource())
@@ -36,7 +36,7 @@ namespace System.Reactive.Disposables
         }
 
         /// <summary>
-        /// Gets the <see cref="T:System.Threading.CancellationToken"/> used by this CancellationDisposable.
+        /// Gets the <see cref="CancellationToken"/> used by this CancellationDisposable.
         /// </summary>
         public CancellationToken Token
         {
@@ -44,7 +44,7 @@ namespace System.Reactive.Disposables
         }
 
         /// <summary>
-        /// Cancels the underlying <seealso cref="T:System.Threading.CancellationTokenSource"/>.
+        /// Cancels the underlying <seealso cref="CancellationTokenSource"/>.
         /// </summary>
         public void Dispose()
         {

Rx.NET/Source/src/System.Reactive/Disposables/CompositeDisposable.cs

@@ -21,7 +21,7 @@ namespace System.Reactive.Disposables
         private const int SHRINK_THRESHOLD = 64;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="T:System.Reactive.Disposables.CompositeDisposable"/> class with no disposables contained by it initially.
+        /// Initializes a new instance of the <see cref="CompositeDisposable"/> class with no disposables contained by it initially.
         /// </summary>
         public CompositeDisposable()
         {
@@ -29,7 +29,7 @@ namespace System.Reactive.Disposables
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="T:System.Reactive.Disposables.CompositeDisposable"/> class with the specified number of disposables.
+        /// Initializes a new instance of the <see cref="CompositeDisposable"/> class with the specified number of disposables.
         /// </summary>
         /// <param name="capacity">The number of disposables that the new CompositeDisposable can initially store.</param>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="capacity"/> is less than zero.</exception>
@@ -42,7 +42,7 @@ namespace System.Reactive.Disposables
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="T:System.Reactive.Disposables.CompositeDisposable"/> class from a group of disposables.
+        /// Initializes a new instance of the <see cref="CompositeDisposable"/> class from a group of disposables.
         /// </summary>
         /// <param name="disposables">Disposables that will be disposed together.</param>
         /// <exception cref="ArgumentNullException"><paramref name="disposables"/> is null.</exception>
@@ -53,7 +53,7 @@ namespace System.Reactive.Disposables
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="T:System.Reactive.Disposables.CompositeDisposable"/> class from a group of disposables.
+        /// Initializes a new instance of the <see cref="CompositeDisposable"/> class from a group of disposables.
         /// </summary>
         /// <param name="disposables">Disposables that will be disposed together.</param>
         /// <exception cref="ArgumentNullException"><paramref name="disposables"/> is null.</exception>

Rx.NET/Source/src/System.Reactive/Disposables/ContextDisposable.cs

@@ -9,7 +9,7 @@ using System.Threading;
 namespace System.Reactive.Disposables
 {
     /// <summary>
-    /// Represents a disposable resource whose disposal invocation will be posted to the specified <seealso cref="T:System.Threading.SynchronizationContext"/>.
+    /// Represents a disposable resource whose disposal invocation will be posted to the specified <seealso cref="SynchronizationContext"/>.
     /// </summary>
     public sealed class ContextDisposable : ICancelable
     {
@@ -17,7 +17,7 @@ namespace System.Reactive.Disposables
         private volatile IDisposable _disposable;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="T:System.Reactive.Disposables.ContextDisposable"/> class that uses the specified <see cref="T:System.Threading.SynchronizationContext"/> on which to dispose the specified disposable resource.
+        /// Initializes a new instance of the <see cref="ContextDisposable"/> class that uses the specified <see cref="SynchronizationContext"/> on which to dispose the specified disposable resource.
         /// </summary>
         /// <param name="context">Context to perform disposal on.</param>
         /// <param name="disposable">Disposable whose Dispose operation to run on the given synchronization context.</param>
@@ -34,7 +34,7 @@ namespace System.Reactive.Disposables
         }
 
         /// <summary>
-        /// Gets the provided <see cref="T:System.Threading.SynchronizationContext"/>.
+        /// Gets the provided <see cref="SynchronizationContext"/>.
         /// </summary>
         public SynchronizationContext Context
         {
@@ -50,7 +50,7 @@ namespace System.Reactive.Disposables
         }
 
         /// <summary>
-        /// Disposes the underlying disposable on the provided <see cref="T:System.Threading.SynchronizationContext"/>.
+        /// Disposes the underlying disposable on the provided <see cref="SynchronizationContext"/>.
         /// </summary>
         public void Dispose()
         {

Rx.NET/Source/src/System.Reactive/Disposables/MultipleAssignmentDisposable.cs

@@ -14,7 +14,7 @@ namespace System.Reactive.Disposables
         private IDisposable _current;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="T:System.Reactive.Disposables.MultipleAssignmentDisposable"/> class with no current underlying disposable.
+        /// Initializes a new instance of the <see cref="MultipleAssignmentDisposable"/> class with no current underlying disposable.
         /// </summary>
         public MultipleAssignmentDisposable()
         {

Rx.NET/Source/src/System.Reactive/Disposables/RefCountDisposable.cs

@@ -19,7 +19,7 @@ namespace System.Reactive.Disposables
         private int _count;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="T:System.Reactive.Disposables.RefCountDisposable"/> class with the specified disposable.
+        /// Initializes a new instance of the <see cref="RefCountDisposable"/> class with the specified disposable.
         /// </summary>
         /// <param name="disposable">Underlying disposable.</param>
         /// <exception cref="ArgumentNullException"><paramref name="disposable"/> is null.</exception>
@@ -29,7 +29,7 @@ namespace System.Reactive.Disposables
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="T:System.Reactive.Disposables.RefCountDisposable"/> class with the specified disposable.
+        /// Initializes a new instance of the <see cref="RefCountDisposable"/> class with the specified disposable.
         /// </summary>
         /// <param name="disposable">Underlying disposable.</param>
         /// <param name="throwWhenDisposed">Indicates whether subsequent calls to <see cref="GetDisposable"/> should throw when this instance is disposed.</param>

Rx.NET/Source/src/System.Reactive/Disposables/ScheduledDisposable.cs

@@ -8,7 +8,7 @@ using System.Threading;
 namespace System.Reactive.Disposables
 {
     /// <summary>
-    /// Represents a disposable resource whose disposal invocation will be scheduled on the specified <seealso cref="T:System.Reactive.Concurrency.IScheduler"/>.
+    /// Represents a disposable resource whose disposal invocation will be scheduled on the specified <seealso cref="IScheduler"/>.
     /// </summary>
     public sealed class ScheduledDisposable : ICancelable
     {
@@ -16,7 +16,7 @@ namespace System.Reactive.Disposables
         private volatile IDisposable _disposable;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="T:System.Reactive.Disposables.ScheduledDisposable"/> class that uses an <see cref="T:System.Reactive.Concurrency.IScheduler"/> on which to dispose the disposable.
+        /// Initializes a new instance of the <see cref="ScheduledDisposable"/> class that uses an <see cref="IScheduler"/> on which to dispose the disposable.
         /// </summary>
         /// <param name="scheduler">Scheduler where the disposable resource will be disposed on.</param>
         /// <param name="disposable">Disposable resource to dispose on the given scheduler.</param>

Rx.NET/Source/src/System.Reactive/Disposables/SerialDisposable.cs

@@ -14,7 +14,7 @@ namespace System.Reactive.Disposables
         private bool _disposed;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="T:System.Reactive.Disposables.SerialDisposable"/> class.
+        /// Initializes a new instance of the <see cref="SerialDisposable"/> class.
         /// </summary>
         public SerialDisposable()
         {

Rx.NET/Source/src/System.Reactive/Disposables/SingleAssignmentDisposable.cs

@@ -8,14 +8,14 @@ namespace System.Reactive.Disposables
 {
     /// <summary>
     /// Represents a disposable resource which only allows a single assignment of its underlying disposable resource.
-    /// If an underlying disposable resource has already been set, future attempts to set the underlying disposable resource will throw an <see cref="T:System.InvalidOperationException"/>.
+    /// If an underlying disposable resource has already been set, future attempts to set the underlying disposable resource will throw an <see cref="InvalidOperationException"/>.
     /// </summary>
     public sealed class SingleAssignmentDisposable : ICancelable
     {
         private volatile IDisposable _current;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="T:System.Reactive.Disposables.SingleAssignmentDisposable"/> class.
+        /// Initializes a new instance of the <see cref="SingleAssignmentDisposable"/> class.
         /// </summary>
         public SingleAssignmentDisposable()
         {

Rx.NET/Source/src/System.Reactive/EventPattern.cs

@@ -58,10 +58,10 @@ namespace System.Reactive
         public TEventArgs EventArgs { get; private set; }
 
         /// <summary>
-        /// Determines whether the current EventPattern&lt;TSender, TEventArgs&gt; object represents the same event as a specified EventPattern&lt;TSender, TEventArgs&gt; object.
+        /// Determines whether the current <see cref="EventPattern{TSender, TEventArgs}"/> object represents the same event as a specified <see cref="EventPattern{TSender, TEventArgs}"/> object.
         /// </summary>
-        /// <param name="other">An object to compare to the current EventPattern&lt;TSender, TEventArgs&gt; object.</param>
-        /// <returns>true if both EventPattern&lt;TSender, TEventArgs&gt; objects represent the same event; otherwise, false.</returns>
+        /// <param name="other">An object to compare to the current <see cref="EventPattern{TSender, TEventArgs}"/> object.</param>
+        /// <returns>true if both <see cref="EventPattern{TSender, TEventArgs}"/> objects represent the same event; otherwise, false.</returns>
         public bool Equals(EventPattern<TSender, TEventArgs> other)
         {
             if (object.ReferenceEquals(null, other))
@@ -73,19 +73,19 @@ namespace System.Reactive
         }
 
         /// <summary>
-        /// Determines whether the specified System.Object is equal to the current EventPattern&lt;TSender, TEventArgs&gt;.
+        /// Determines whether the specified System.Object is equal to the current <see cref="EventPattern{TSender, TEventArgs}"/>.
         /// </summary>
-        /// <param name="obj">The System.Object to compare with the current EventPattern&lt;TSender, TEventArgs&gt;.</param>
-        /// <returns>true if the specified System.Object is equal to the current EventPattern&lt;TSender, TEventArgs&gt;; otherwise, false.</returns>
+        /// <param name="obj">The System.Object to compare with the current <see cref="EventPattern{TSender, TEventArgs}"/>.</param>
+        /// <returns>true if the specified System.Object is equal to the current <see cref="EventPattern{TSender, TEventArgs}"/>; otherwise, false.</returns>
         public override bool Equals(object obj)
         {
             return Equals(obj as EventPattern<TSender, TEventArgs>);
         }
 
         /// <summary>
-        /// Returns the hash code for the current EventPattern&lt;TSender, TEventArgs&gt; instance.
+        /// Returns the hash code for the current <see cref="EventPattern{TSender, TEventArgs}"/> instance.
         /// </summary>
-        /// <returns>A hash code for the current EventPattern&lt;TSender, TEventArgs&gt; instance.</returns>
+        /// <returns>A hash code for the current <see cref="EventPattern{TSender, TEventArgs}"/> instance.</returns>
         public override int GetHashCode()
         {
             var x = EqualityComparer<TSender>.Default.GetHashCode(Sender);
@@ -94,22 +94,22 @@ namespace System.Reactive
         }
 
         /// <summary>
-        /// Determines whether two specified EventPattern&lt;TSender, TEventArgs&gt; objects represent the same event.
+        /// Determines whether two specified <see cref="EventPattern{TSender, TEventArgs}"/> objects represent the same event.
         /// </summary>
-        /// <param name="first">The first EventPattern&lt;TSender, TEventArgs&gt; to compare, or null.</param>
-        /// <param name="second">The second EventPattern&lt;TSender, TEventArgs&gt; to compare, or null.</param>
-        /// <returns>true if both EventPattern&lt;TSender, TEventArgs&gt; objects represent the same event; otherwise, false.</returns>
+        /// <param name="first">The first <see cref="EventPattern{TSender, TEventArgs}"/> to compare, or null.</param>
+        /// <param name="second">The second <see cref="EventPattern{TSender, TEventArgs}"/> to compare, or null.</param>
+        /// <returns>true if both <see cref="EventPattern{TSender, TEventArgs}"/> objects represent the same event; otherwise, false.</returns>
         public static bool operator ==(EventPattern<TSender, TEventArgs> first, EventPattern<TSender, TEventArgs> second)
         {
             return object.Equals(first, second);
         }
 
         /// <summary>
-        /// Determines whether two specified EventPattern&lt;TSender, TEventArgs&gt; objects represent a different event.
+        /// Determines whether two specified <see cref="EventPattern{TSender, TEventArgs}"/> objects represent a different event.
         /// </summary>
-        /// <param name="first">The first EventPattern&lt;TSender, TEventArgs&gt; to compare, or null.</param>
-        /// <param name="second">The second EventPattern&lt;TSender, TEventArgs&gt; to compare, or null.</param>
-        /// <returns>true if both EventPattern&lt;TSender, TEventArgs&gt; objects don't represent the same event; otherwise, false.</returns>
+        /// <param name="first">The first <see cref="EventPattern{TSender, TEventArgs}"/> to compare, or null.</param>
+        /// <param name="second">The second <see cref="EventPattern{TSender, TEventArgs}"/> to compare, or null.</param>
+        /// <returns>true if both <see cref="EventPattern{TSender, TEventArgs}"/> objects don't represent the same event; otherwise, false.</returns>
         public static bool operator !=(EventPattern<TSender, TEventArgs> first, EventPattern<TSender, TEventArgs> second)
         {
             return !object.Equals(first, second);

Rx.NET/Source/src/System.Reactive/Linq/IQbservableProvider.cs

@@ -14,9 +14,9 @@ namespace System.Reactive.Linq
     public interface IQbservableProvider
     {
         /// <summary>
-        /// Constructs an IQbservable&gt;TResult&lt; object that can evaluate the query represented by a specified expression tree.
+        /// Constructs an <see cref="IQbservable{T}"/> object that can evaluate the query represented by a specified expression tree.
         /// </summary>
-        /// <typeparam name="TResult">The type of the elements of the System.Reactive.Linq.IQbservable&lt;T&gt; that is returned.</typeparam>
+        /// <typeparam name="TResult">The type of the elements of the <see cref="IQbservable{T}"/> that is returned.</typeparam>
         /// <param name="expression">Expression tree representing the query.</param>
         /// <returns>IQbservable object that can evaluate the given query expression.</returns>
         IQbservable<TResult> CreateQuery<TResult>(Expression expression);

Rx.NET/Source/src/System.Reactive/Linq/Observable.Binding.cs

@@ -63,14 +63,14 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns a connectable observable sequence that shares a single subscription to the underlying sequence.
-        /// This operator is a specialization of Multicast using a regular <see cref="System.Reactive.Subjects.Subject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a regular <see cref="Subject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Source sequence whose elements will be multicasted through a single shared subscription.</param>
         /// <returns>A connectable observable sequence that shares a single subscription to the underlying sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>Subscribers will receive all notifications of the source from the time of the subscription on.</remarks>
-        /// <seealso cref="System.Reactive.Subjects.Subject&lt;T&gt;"/>
+        /// <seealso cref="Subject{T}"/>
         public static IConnectableObservable<TSource> Publish<TSource>(this IObservable<TSource> source)
         {
             if (source == null)
@@ -81,7 +81,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence.
-        /// This operator is a specialization of Multicast using a regular <see cref="System.Reactive.Subjects.Subject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a regular <see cref="Subject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -89,7 +89,7 @@ namespace System.Reactive.Linq
         /// <param name="selector">Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all notifications of the source from the time of the subscription on.</param>
         /// <returns>An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <seealso cref="System.Reactive.Subjects.Subject&lt;T&gt;"/>
+        /// <seealso cref="Subject{T}"/>
         public static IObservable<TResult> Publish<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector)
         {
             if (source == null)
@@ -102,7 +102,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.BehaviorSubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="BehaviorSubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Source sequence whose elements will be multicasted through a single shared subscription.</param>
@@ -110,7 +110,7 @@ namespace System.Reactive.Linq
         /// <returns>A connectable observable sequence that shares a single subscription to the underlying sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>Subscribers will receive immediately receive the initial value, followed by all notifications of the source from the time of the subscription on.</remarks>
-        /// <seealso cref="System.Reactive.Subjects.BehaviorSubject&lt;T&gt;"/>
+        /// <seealso cref="BehaviorSubject{T}"/>
         public static IConnectableObservable<TSource> Publish<TSource>(this IObservable<TSource> source, TSource initialValue)
         {
             if (source == null)
@@ -121,7 +121,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.BehaviorSubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="BehaviorSubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -130,7 +130,7 @@ namespace System.Reactive.Linq
         /// <param name="initialValue">Initial value received by observers upon subscription.</param>
         /// <returns>An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <seealso cref="System.Reactive.Subjects.BehaviorSubject&lt;T&gt;"/>
+        /// <seealso cref="BehaviorSubject{T}"/>
         public static IObservable<TResult> Publish<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, TSource initialValue)
         {
             if (source == null)
@@ -147,14 +147,14 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.AsyncSubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="AsyncSubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Source sequence whose elements will be multicasted through a single shared subscription.</param>
         /// <returns>A connectable observable sequence that shares a single subscription to the underlying sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>Subscribers will only receive the last notification of the source.</remarks>
-        /// <seealso cref="System.Reactive.Subjects.AsyncSubject&lt;T&gt;"/>
+        /// <seealso cref="AsyncSubject{T}"/>
         public static IConnectableObservable<TSource> PublishLast<TSource>(this IObservable<TSource> source)
         {
             if (source == null)
@@ -165,7 +165,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.AsyncSubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="AsyncSubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -173,7 +173,7 @@ namespace System.Reactive.Linq
         /// <param name="selector">Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will only receive the last notification of the source.</param>
         /// <returns>An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <seealso cref="System.Reactive.Subjects.AsyncSubject&lt;T&gt;"/>
+        /// <seealso cref="AsyncSubject{T}"/>
         public static IObservable<TResult> PublishLast<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector)
         {
             if (source == null)
@@ -209,14 +209,14 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="ReplaySubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Source sequence whose elements will be multicasted through a single shared subscription.</param>
         /// <returns>A connectable observable sequence that shares a single subscription to the underlying sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>Subscribers will receive all the notifications of the source.</remarks>
-        /// <seealso cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>
+        /// <seealso cref="ReplaySubject{T}"/>
         public static IConnectableObservable<TSource> Replay<TSource>(this IObservable<TSource> source)
         {
             if (source == null)
@@ -227,7 +227,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="ReplaySubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Source sequence whose elements will be multicasted through a single shared subscription.</param>
@@ -235,7 +235,7 @@ namespace System.Reactive.Linq
         /// <returns>A connectable observable sequence that shares a single subscription to the underlying sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="scheduler"/> is null.</exception>
         /// <remarks>Subscribers will receive all the notifications of the source.</remarks>
-        /// <seealso cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>
+        /// <seealso cref="ReplaySubject{T}"/>
         public static IConnectableObservable<TSource> Replay<TSource>(this IObservable<TSource> source, IScheduler scheduler)
         {
             if (source == null)
@@ -248,7 +248,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="ReplaySubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -256,7 +256,7 @@ namespace System.Reactive.Linq
         /// <param name="selector">Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source.</param>
         /// <returns>An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <seealso cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>
+        /// <seealso cref="ReplaySubject{T}"/>
         public static IObservable<TResult> Replay<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector)
         {
             if (source == null)
@@ -269,7 +269,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="ReplaySubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -278,7 +278,7 @@ namespace System.Reactive.Linq
         /// <param name="scheduler">Scheduler where connected observers within the selector function will be invoked on.</param>
         /// <returns>An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> or <paramref name="scheduler"/> is null.</exception>
-        /// <seealso cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>
+        /// <seealso cref="ReplaySubject{T}"/>
         public static IObservable<TResult> Replay<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, IScheduler scheduler)
         {
             if (source == null)
@@ -293,7 +293,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="ReplaySubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Source sequence whose elements will be multicasted through a single shared subscription.</param>
@@ -302,7 +302,7 @@ namespace System.Reactive.Linq
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="window"/> is less than TimeSpan.Zero.</exception>
         /// <remarks>Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy.</remarks>
-        /// <seealso cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>
+        /// <seealso cref="ReplaySubject{T}"/>
         public static IConnectableObservable<TSource> Replay<TSource>(this IObservable<TSource> source, TimeSpan window)
         {
             if (source == null)
@@ -315,7 +315,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="ReplaySubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -325,7 +325,7 @@ namespace System.Reactive.Linq
         /// <returns>An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="window"/> is less than TimeSpan.Zero.</exception>
-        /// <seealso cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>
+        /// <seealso cref="ReplaySubject{T}"/>
         public static IObservable<TResult> Replay<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, TimeSpan window)
         {
             if (source == null)
@@ -340,7 +340,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="ReplaySubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Source sequence whose elements will be multicasted through a single shared subscription.</param>
@@ -350,7 +350,7 @@ namespace System.Reactive.Linq
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="scheduler"/> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="window"/> is less than TimeSpan.Zero.</exception>
         /// <remarks>Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy.</remarks>
-        /// <seealso cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>
+        /// <seealso cref="ReplaySubject{T}"/>
         public static IConnectableObservable<TSource> Replay<TSource>(this IObservable<TSource> source, TimeSpan window, IScheduler scheduler)
         {
             if (source == null)
@@ -365,7 +365,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="ReplaySubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -376,7 +376,7 @@ namespace System.Reactive.Linq
         /// <returns>An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> or <paramref name="scheduler"/> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="window"/> is less than TimeSpan.Zero.</exception>
-        /// <seealso cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>
+        /// <seealso cref="ReplaySubject{T}"/>
         public static IObservable<TResult> Replay<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, TimeSpan window, IScheduler scheduler)
         {
             if (source == null)
@@ -393,7 +393,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize notifications.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="ReplaySubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Source sequence whose elements will be multicasted through a single shared subscription.</param>
@@ -403,7 +403,7 @@ namespace System.Reactive.Linq
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="scheduler"/> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="bufferSize"/> is less than zero.</exception>
         /// <remarks>Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy.</remarks>
-        /// <seealso cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>
+        /// <seealso cref="ReplaySubject{T}"/>
         public static IConnectableObservable<TSource> Replay<TSource>(this IObservable<TSource> source, int bufferSize, IScheduler scheduler)
         {
             if (source == null)
@@ -418,7 +418,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="ReplaySubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -429,7 +429,7 @@ namespace System.Reactive.Linq
         /// <returns>An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> or <paramref name="scheduler"/> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="bufferSize"/> is less than zero.</exception>
-        /// <seealso cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>
+        /// <seealso cref="ReplaySubject{T}"/>
         public static IObservable<TResult> Replay<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, int bufferSize, IScheduler scheduler)
         {
             if (source == null)
@@ -446,7 +446,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="ReplaySubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Source sequence whose elements will be multicasted through a single shared subscription.</param>
@@ -455,7 +455,7 @@ namespace System.Reactive.Linq
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="bufferSize"/> is less than zero.</exception>
         /// <remarks>Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy.</remarks>
-        /// <seealso cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>
+        /// <seealso cref="ReplaySubject{T}"/>
         public static IConnectableObservable<TSource> Replay<TSource>(this IObservable<TSource> source, int bufferSize)
         {
             if (source == null)
@@ -468,7 +468,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="ReplaySubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -478,7 +478,7 @@ namespace System.Reactive.Linq
         /// <returns>An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="bufferSize"/> is less than zero.</exception>
-        /// <seealso cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>
+        /// <seealso cref="ReplaySubject{T}"/>
         public static IObservable<TResult> Replay<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, int bufferSize)
         {
             if (source == null)
@@ -493,7 +493,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="ReplaySubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Source sequence whose elements will be multicasted through a single shared subscription.</param>
@@ -504,7 +504,7 @@ namespace System.Reactive.Linq
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="bufferSize"/> is less than zero.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="window"/> is less than TimeSpan.Zero.</exception>
         /// <remarks>Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy.</remarks>
-        /// <seealso cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>
+        /// <seealso cref="ReplaySubject{T}"/>
         public static IConnectableObservable<TSource> Replay<TSource>(this IObservable<TSource> source, int bufferSize, TimeSpan window)
         {
             if (source == null)
@@ -519,7 +519,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="ReplaySubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -531,7 +531,7 @@ namespace System.Reactive.Linq
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="bufferSize"/> is less than zero.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="window"/> is less than TimeSpan.Zero.</exception>
-        /// <seealso cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>
+        /// <seealso cref="ReplaySubject{T}"/>
         public static IObservable<TResult> Replay<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, int bufferSize, TimeSpan window)
         {
             if (source == null)
@@ -548,7 +548,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="ReplaySubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Source sequence whose elements will be multicasted through a single shared subscription.</param>
@@ -560,7 +560,7 @@ namespace System.Reactive.Linq
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="bufferSize"/> is less than zero.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="window"/> is less than TimeSpan.Zero.</exception>
         /// <remarks>Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy.</remarks>
-        /// <seealso cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>
+        /// <seealso cref="ReplaySubject{T}"/>
         public static IConnectableObservable<TSource> Replay<TSource>(this IObservable<TSource> source, int bufferSize, TimeSpan window, IScheduler scheduler)
         {
             if (source == null)
@@ -577,7 +577,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer.
-        /// This operator is a specialization of Multicast using a <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>.
+        /// This operator is a specialization of Multicast using a <see cref="ReplaySubject{T}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -590,7 +590,7 @@ namespace System.Reactive.Linq
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> or <paramref name="scheduler"/> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="bufferSize"/> is less than zero.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="window"/> is less than TimeSpan.Zero.</exception>
-        /// <seealso cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/>
+        /// <seealso cref="ReplaySubject{T}"/>
         public static IObservable<TResult> Replay<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, int bufferSize, TimeSpan window, IScheduler scheduler)
         {
             if (source == null)

Rx.NET/Source/src/System.Reactive/Linq/Observable.Conversions.cs

@@ -74,7 +74,7 @@ namespace System.Reactive.Linq
         #region ToEvent
 
         /// <summary>
-        /// Exposes an observable sequence as an object with an Action-based .NET event.
+        /// Exposes an observable sequence as an object with an <see cref="Action"/>-based .NET event.
         /// </summary>
         /// <param name="source">Observable source sequence.</param>
         /// <returns>The event source object.</returns>
@@ -88,7 +88,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Exposes an observable sequence as an object with an Action&lt;TSource&gt;-based .NET event.
+        /// Exposes an observable sequence as an object with an <see cref="Action{TSource}"/>-based .NET event.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Observable source sequence.</param>

Rx.NET/Source/src/System.Reactive/Linq/Observable.Creation.cs

@@ -24,9 +24,9 @@ namespace System.Reactive.Linq
         /// <returns>The observable sequence with the specified implementation for the Subscribe method.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="subscribe"/> is null.</exception>
         /// <remarks>
-        /// Use of this operator is preferred over manual implementation of the IObservable&lt;T&gt; interface. In case
-        /// you need a type implementing IObservable&lt;T&gt; rather than an anonymous implementation, consider using
-        /// the <see cref="System.Reactive.ObservableBase&lt;T&gt;"/> abstract base class.
+        /// Use of this operator is preferred over manual implementation of the <see cref="IObservable{T}"/> interface. In case
+        /// you need a type implementing <see cref="IObservable{T}"/> rather than an anonymous implementation, consider using
+        /// the <see cref="ObservableBase{T}"/> abstract base class.
         /// </remarks>
         public static IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, IDisposable> subscribe)
         {
@@ -44,9 +44,9 @@ namespace System.Reactive.Linq
         /// <returns>The observable sequence with the specified implementation for the Subscribe method.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="subscribe"/> is null.</exception>
         /// <remarks>
-        /// Use of this operator is preferred over manual implementation of the IObservable&lt;T&gt; interface. In case
-        /// you need a type implementing IObservable&lt;T&gt; rather than an anonymous implementation, consider using
-        /// the <see cref="System.Reactive.ObservableBase&lt;T&gt;"/> abstract base class.
+        /// Use of this operator is preferred over manual implementation of the <see cref="IObservable{T}"/> interface. In case
+        /// you need a type implementing <see cref="IObservable{T}"/> rather than an anonymous implementation, consider using
+        /// the <see cref="ObservableBase{T}"/> abstract base class.
         /// </remarks>
         public static IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, Action> subscribe)
         {
@@ -230,7 +230,7 @@ namespace System.Reactive.Linq
         /// <summary>
         /// Returns an empty observable sequence.
         /// </summary>
-        /// <typeparam name="TResult">The type used for the IObservable&lt;T&gt; type parameter of the resulting sequence.</typeparam>
+        /// <typeparam name="TResult">The type used for the <see cref="IObservable{T}"/> type parameter of the resulting sequence.</typeparam>
         /// <returns>An observable sequence with no elements.</returns>
         public static IObservable<TResult> Empty<TResult>()
         {
@@ -240,7 +240,7 @@ namespace System.Reactive.Linq
         /// <summary>
         /// Returns an empty observable sequence.
         /// </summary>
-        /// <typeparam name="TResult">The type used for the IObservable&lt;T&gt; type parameter of the resulting sequence.</typeparam>
+        /// <typeparam name="TResult">The type used for the <see cref="IObservable{T}"/> type parameter of the resulting sequence.</typeparam>
         /// <param name="witness">Object solely used to infer the type of the <typeparamref name="TResult"/> type parameter. This parameter is typically used when creating a sequence of anonymously typed elements.</param>
         /// <returns>An observable sequence with no elements.</returns>
         public static IObservable<TResult> Empty<TResult>(TResult witness)
@@ -251,7 +251,7 @@ namespace System.Reactive.Linq
         /// <summary>
         /// Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message.
         /// </summary>
-        /// <typeparam name="TResult">The type used for the IObservable&lt;T&gt; type parameter of the resulting sequence.</typeparam>
+        /// <typeparam name="TResult">The type used for the <see cref="IObservable{T}"/> type parameter of the resulting sequence.</typeparam>
         /// <param name="scheduler">Scheduler to send the termination call on.</param>
         /// <returns>An observable sequence with no elements.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="scheduler"/> is null.</exception>
@@ -266,7 +266,7 @@ namespace System.Reactive.Linq
         /// <summary>
         /// Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message.
         /// </summary>
-        /// <typeparam name="TResult">The type used for the IObservable&lt;T&gt; type parameter of the resulting sequence.</typeparam>
+        /// <typeparam name="TResult">The type used for the <see cref="IObservable{T}"/> type parameter of the resulting sequence.</typeparam>
         /// <param name="scheduler">Scheduler to send the termination call on.</param>
         /// <param name="witness">Object solely used to infer the type of the <typeparamref name="TResult"/> type parameter. This parameter is typically used when creating a sequence of anonymously typed elements.</param>
         /// <returns>An observable sequence with no elements.</returns>
@@ -339,7 +339,7 @@ namespace System.Reactive.Linq
         /// <summary>
         /// Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins).
         /// </summary>
-        /// <typeparam name="TResult">The type used for the IObservable&lt;T&gt; type parameter of the resulting sequence.</typeparam>
+        /// <typeparam name="TResult">The type used for the <see cref="IObservable{T}"/> type parameter of the resulting sequence.</typeparam>
         /// <returns>An observable sequence whose observers will never get called.</returns>
         public static IObservable<TResult> Never<TResult>()
         {
@@ -349,7 +349,7 @@ namespace System.Reactive.Linq
         /// <summary>
         /// Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins).
         /// </summary>
-        /// <typeparam name="TResult">The type used for the IObservable&lt;T&gt; type parameter of the resulting sequence.</typeparam>
+        /// <typeparam name="TResult">The type used for the <see cref="IObservable{T}"/> type parameter of the resulting sequence.</typeparam>
         /// <param name="witness">Object solely used to infer the type of the <typeparamref name="TResult"/> type parameter. This parameter is typically used when creating a sequence of anonymously typed elements.</param>
         /// <returns>An observable sequence whose observers will never get called.</returns>
         public static IObservable<TResult> Never<TResult>(TResult witness)
@@ -367,7 +367,7 @@ namespace System.Reactive.Linq
         /// <param name="start">The value of the first integer in the sequence.</param>
         /// <param name="count">The number of sequential integers to generate.</param>
         /// <returns>An observable sequence that contains a range of sequential integral numbers.</returns>
-        /// <exception cref="ArgumentOutOfRangeException"><paramref name="count"/> is less than zero. -or- <paramref name="start"/> + <paramref name="count"/> - 1 is larger than <see cref="M:System.Int32.MaxValue"/>.</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="count"/> is less than zero. -or- <paramref name="start"/> + <paramref name="count"/> - 1 is larger than <see cref="Int32.MaxValue"/>.</exception>
         public static IObservable<int> Range(int start, int count)
         {
             var max = ((long)start) + count - 1;
@@ -384,7 +384,7 @@ namespace System.Reactive.Linq
         /// <param name="count">The number of sequential integers to generate.</param>
         /// <param name="scheduler">Scheduler to run the generator loop on.</param>
         /// <returns>An observable sequence that contains a range of sequential integral numbers.</returns>
-        /// <exception cref="ArgumentOutOfRangeException"><paramref name="count"/> is less than zero. -or- <paramref name="start"/> + <paramref name="count"/> - 1 is larger than <see cref="M:System.Int32.MaxValue"/>.</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="count"/> is less than zero. -or- <paramref name="start"/> + <paramref name="count"/> - 1 is larger than <see cref="Int32.MaxValue"/>.</exception>
         /// <exception cref="ArgumentNullException"><paramref name="scheduler"/> is null.</exception>
         public static IObservable<int> Range(int start, int count, IScheduler scheduler)
         {
@@ -503,7 +503,7 @@ namespace System.Reactive.Linq
         /// <summary>
         /// Returns an observable sequence that terminates with an exception.
         /// </summary>
-        /// <typeparam name="TResult">The type used for the IObservable&lt;T&gt; type parameter of the resulting sequence.</typeparam>
+        /// <typeparam name="TResult">The type used for the <see cref="IObservable{T}"/> type parameter of the resulting sequence.</typeparam>
         /// <param name="exception">Exception object used for the sequence's termination.</param>
         /// <returns>The observable sequence that terminates exceptionally with the specified exception object.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="exception"/> is null.</exception>
@@ -518,7 +518,7 @@ namespace System.Reactive.Linq
         /// <summary>
         /// Returns an observable sequence that terminates with an exception.
         /// </summary>
-        /// <typeparam name="TResult">The type used for the IObservable&lt;T&gt; type parameter of the resulting sequence.</typeparam>
+        /// <typeparam name="TResult">The type used for the <see cref="IObservable{T}"/> type parameter of the resulting sequence.</typeparam>
         /// <param name="exception">Exception object used for the sequence's termination.</param>
         /// <param name="witness">Object solely used to infer the type of the <typeparamref name="TResult"/> type parameter. This parameter is typically used when creating a sequence of anonymously typed elements.</param>
         /// <returns>The observable sequence that terminates exceptionally with the specified exception object.</returns>
@@ -534,7 +534,7 @@ namespace System.Reactive.Linq
         /// <summary>
         /// Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message.
         /// </summary>
-        /// <typeparam name="TResult">The type used for the IObservable&lt;T&gt; type parameter of the resulting sequence.</typeparam>
+        /// <typeparam name="TResult">The type used for the <see cref="IObservable{T}"/> type parameter of the resulting sequence.</typeparam>
         /// <param name="exception">Exception object used for the sequence's termination.</param>
         /// <param name="scheduler">Scheduler to send the exceptional termination call on.</param>
         /// <returns>The observable sequence that terminates exceptionally with the specified exception object.</returns>
@@ -552,7 +552,7 @@ namespace System.Reactive.Linq
         /// <summary>
         /// Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message.
         /// </summary>
-        /// <typeparam name="TResult">The type used for the IObservable&lt;T&gt; type parameter of the resulting sequence.</typeparam>
+        /// <typeparam name="TResult">The type used for the <see cref="IObservable{T}"/> type parameter of the resulting sequence.</typeparam>
         /// <param name="exception">Exception object used for the sequence's termination.</param>
         /// <param name="scheduler">Scheduler to send the exceptional termination call on.</param>
         /// <param name="witness">Object solely used to infer the type of the <typeparamref name="TResult"/> type parameter. This parameter is typically used when creating a sequence of anonymously typed elements.</param>

Rx.NET/Source/src/System.Reactive/Linq/Observable.Events.cs

@@ -210,7 +210,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Converts a .NET event, conforming to the standard .NET event pattern based on <see cref="EventHandler&lt;TEventArgs&gt;"/>, to an observable sequence.
+        /// Converts a .NET event, conforming to the standard .NET event pattern based on <see cref="EventHandler{TEventArgs}"/>, to an observable sequence.
         /// Each event invocation is surfaced through an OnNext message in the resulting sequence.
         /// For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.
         /// </summary>
@@ -257,7 +257,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Converts a .NET event, conforming to the standard .NET event pattern based on <see cref="EventHandler&lt;TEventArgs&gt;"/>, to an observable sequence.
+        /// Converts a .NET event, conforming to the standard .NET event pattern based on <see cref="EventHandler{TEventArgs}"/>, to an observable sequence.
         /// Each event invocation is surfaced through an OnNext message in the resulting sequence.
         /// For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.
         /// </summary>
@@ -396,7 +396,7 @@ namespace System.Reactive.Linq
         #region Action<EventHandler<TEventArgs>>
 
         /// <summary>
-        /// Converts a .NET event, conforming to the standard .NET event pattern based on <see cref="EventHandler&lt;TEventArgs&gt;"/>, to an observable sequence.
+        /// Converts a .NET event, conforming to the standard .NET event pattern based on <see cref="EventHandler{TEventArgs}"/>, to an observable sequence.
         /// Each event invocation is surfaced through an OnNext message in the resulting sequence.
         /// For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.
         /// </summary>
@@ -438,7 +438,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Converts a .NET event, conforming to the standard .NET event pattern based on <see cref="EventHandler&lt;TEventArgs&gt;"/>, to an observable sequence.
+        /// Converts a .NET event, conforming to the standard .NET event pattern based on <see cref="EventHandler{TEventArgs}"/>, to an observable sequence.
         /// Each event invocation is surfaced through an OnNext message in the resulting sequence.
         /// For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.
         /// </summary>

Rx.NET/Source/src/System.Reactive/Linq/Observable.Queryable.cs

@@ -25,11 +25,11 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Converts an in-memory observable sequence into an IQbservable&lt;T&gt; sequence with an expression tree representing the source sequence.
+        /// Converts an in-memory observable sequence into an <see cref="IQbservable{T}"/> sequence with an expression tree representing the source sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Source sequence.</param>
-        /// <returns>IQbservable&lt;T&gt; sequence representing the given observable source sequence.</returns>
+        /// <returns><see cref="IQbservable{T}"/> sequence representing the given observable source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         public static IQbservable<TSource> AsQbservable<TSource>(this IObservable<TSource> source)
         {

Rx.NET/Source/src/System.Reactive/Linq/Observable.Single.cs

@@ -421,7 +421,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Applies an accumulator function over an observable sequence and returns each intermediate result. The specified seed value is used as the initial accumulator value.
-        /// For aggregation behavior with no intermediate results, see <see cref="Observable.Aggregate&lt;TSource, Accumulate&gt;"/>.
+        /// For aggregation behavior with no intermediate results, see <see cref="Observable.Aggregate{TSource, Accumulate}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TAccumulate">The type of the result of the aggregation.</typeparam>
@@ -442,7 +442,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Applies an accumulator function over an observable sequence and returns each intermediate result.
-        /// For aggregation behavior with no intermediate results, see <see cref="Observable.Aggregate&lt;TSource&gt;"/>.
+        /// For aggregation behavior with no intermediate results, see <see cref="Observable.Aggregate{TSource}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence and the result of the aggregation.</typeparam>
         /// <param name="source">An observable sequence to accumulate over.</param>

Rx.NET/Source/src/System.Reactive/Linq/Observable.StandardSequenceOperators.cs

@@ -1098,7 +1098,7 @@ namespace System.Reactive.Linq
         /// <param name="selector">A transform function to apply to each element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable&lt;TSource&gt;(IEnumerable&lt;TSource&gt;)"/> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})"/> conversion.</remarks>
         public static IObservable<TResult> SelectMany<TSource, TResult>(this IObservable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
         {
             if (source == null)
@@ -1118,7 +1118,7 @@ namespace System.Reactive.Linq
         /// <param name="selector">A transform function to apply to each element; the second parameter of the function represents the index of the source element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable&lt;TSource&gt;(IEnumerable&lt;TSource&gt;)"/> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})"/> conversion.</remarks>
         public static IObservable<TResult> SelectMany<TSource, TResult>(this IObservable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
         {
             if (source == null)
@@ -1140,7 +1140,7 @@ namespace System.Reactive.Linq
         /// <param name="resultSelector">A transform function to apply to each element of the intermediate sequence.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="collectionSelector"/> or <paramref name="resultSelector"/> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable&lt;TSource&gt;(IEnumerable&lt;TSource&gt;)"/> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})"/> conversion.</remarks>
         public static IObservable<TResult> SelectMany<TSource, TCollection, TResult>(this IObservable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
         {
             if (source == null)
@@ -1164,7 +1164,7 @@ namespace System.Reactive.Linq
         /// <param name="resultSelector">A transform function to apply to each element of the intermediate sequence; the second parameter of the function represents the index of the source element and the fourth parameter represents the index of the intermediate element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="collectionSelector"/> or <paramref name="resultSelector"/> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable&lt;TSource&gt;(IEnumerable&lt;TSource&gt;)"/> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})"/> conversion.</remarks>
         public static IObservable<TResult> SelectMany<TSource, TCollection, TResult>(this IObservable<TSource> source, Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, int, TCollection, int, TResult> resultSelector)
         {
             if (source == null)

Rx.NET/Source/src/System.Reactive/Linq/Qbservable.Joins.cs

@@ -80,7 +80,7 @@ namespace System.Reactive.Linq
         /// Joins together the results from several patterns.
         /// </summary>
         /// <typeparam name="TResult">The type of the elements in the result sequence, obtained from the specified patterns.</typeparam>
-        /// <param name="provider">Query provider used to construct the IQbservable&lt;T&gt; data source.</param>
+        /// <param name="provider">Query provider used to construct the <see cref="IQbservable{T}"/> data source.</param>
         /// <param name="plans">A series of plans created by use of the Then operator on patterns.</param>
         /// <returns>An observable sequence with the results from matching several patterns.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="provider"/> or <paramref name="plans"/> is null.</exception>
@@ -112,7 +112,7 @@ namespace System.Reactive.Linq
         /// Joins together the results from several patterns.
         /// </summary>
         /// <typeparam name="TResult">The type of the elements in the result sequence, obtained from the specified patterns.</typeparam>
-        /// <param name="provider">Query provider used to construct the IQbservable&lt;T&gt; data source.</param>
+        /// <param name="provider">Query provider used to construct the <see cref="IQbservable{T}"/> data source.</param>
         /// <param name="plans">A series of plans created by use of the Then operator on patterns.</param>
         /// <returns>An observable sequence with the results form matching several patterns.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="provider"/> or <paramref name="plans"/> is null.</exception>

Rx.NET/Source/src/System.Reactive/Linq/Qbservable.cs

@@ -20,12 +20,12 @@ namespace System.Reactive.Linq
     public static partial class Qbservable
     {
         /// <summary>
-        /// Returns the input typed as an IObservable&lt;TSource&gt;.
+        /// Returns the input typed as an <see cref="IObservable{TSource}"/>.
         /// This operator is used to separate the part of the query that's captured as an expression tree from the part that's executed locally.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">An IQbservable&lt;TSource&gt; sequence to convert to an IObservable&lt;TSource&gt; sequence.</param>
-        /// <returns>The original source object, but typed as an IObservable&lt;TSource&gt;.</returns>
+        /// <param name="source">An <see cref="IQbservable{TSource}"/> sequence to convert to an <see cref="IObservable{TSource}"/> sequence.</param>
+        /// <returns>The original source object, but typed as an <see cref="IObservable{TSource}"/>.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         public static IObservable<TSource> AsObservable<TSource>(this IQbservable<TSource> source)
         {

Rx.NET/Source/src/System.Reactive/Linq/QbservableEx.Generated.cs

@@ -32,10 +32,10 @@ namespace System.Reactive.Linq
         /// <summary>
         /// Subscribes to each observable sequence returned by the iteratorMethod in sequence and produces a Unit value on the resulting sequence for each step of the iteration.
         /// </summary>
-        /// <param name="provider">Query provider used to construct the IQbservable&lt;T&gt; data source.</param>
+        /// <param name="provider">Query provider used to construct the <see cref="IQbservable{T}"/> data source.</param>
         /// <param name="iteratorMethod">Iterator method that drives the resulting observable sequence.</param>
         /// <returns>An observable sequence obtained by running the iterator and returning Unit values for each iteration step.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="iteratorMethod" /> is null.</exception>
         [Experimental]
         public static IQbservable<Unit> Create(this IQbservableProvider provider, Expression<Func<IEnumerable<IObservable<object>>>> iteratorMethod)
@@ -64,11 +64,11 @@ namespace System.Reactive.Linq
         /// <summary>
         /// Subscribes to each observable sequence returned by the iteratorMethod in sequence and returns the observable sequence of values sent to the observer given to the iteratorMethod.
         /// </summary>
-        /// <param name="provider">Query provider used to construct the IQbservable&lt;T&gt; data source.</param>
+        /// <param name="provider">Query provider used to construct the <see cref="IQbservable{T}"/> data source.</param>
         /// <typeparam name="TResult">The type of the elements in the produced sequence.</typeparam>
         /// <param name="iteratorMethod">Iterator method that produces elements in the resulting sequence by calling the given observer.</param>
         /// <returns>An observable sequence obtained by running the iterator and returning the elements that were sent to the observer.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="iteratorMethod" /> is null.</exception>
         [Experimental]
         public static IQbservable<TResult> Create<TResult>(this IQbservableProvider provider, Expression<Func<IObserver<TResult>, IEnumerable<IObservable<object>>>> iteratorMethod)
@@ -101,7 +101,7 @@ namespace System.Reactive.Linq
         /// <param name="source">Source sequence with the initial elements.</param>
         /// <param name="selector">Selector function to invoke for each produced element, resulting in another sequence to which the selector will be invoked recursively again.</param>
         /// <returns>An observable sequence containing all the elements produced by the recursive expansion.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         [Experimental]
         public static IQbservable<TSource> Expand<TSource>(this IQbservable<TSource> source, Expression<Func<TSource, IObservable<TSource>>> selector)
@@ -135,7 +135,7 @@ namespace System.Reactive.Linq
         /// <param name="selector">Selector function to invoke for each produced element, resulting in another sequence to which the selector will be invoked recursively again.</param>
         /// <param name="scheduler">Scheduler on which to perform the expansion by enumerating the internal queue of obtained sequences.</param>
         /// <returns>An observable sequence containing all the elements produced by the recursive expansion.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> or <paramref name="scheduler" /> is null.</exception>
         [Experimental]
         public static IQbservable<TSource> Expand<TSource>(this IQbservable<TSource> source, Expression<Func<TSource, IObservable<TSource>>> selector, IScheduler scheduler)
@@ -167,11 +167,11 @@ namespace System.Reactive.Linq
         /// <summary>
         /// Runs all specified observable sequences in parallel and collects their last elements.
         /// </summary>
-        /// <param name="provider">Query provider used to construct the IQbservable&lt;T&gt; data source.</param>
+        /// <param name="provider">Query provider used to construct the <see cref="IQbservable{T}"/> data source.</param>
         /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
         /// <param name="sources">Observable sequence to collect the last elements for.</param>
         /// <returns>An observable sequence with an array collecting the last elements of all the input sequences.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="sources" /> is null.</exception>
         [Experimental]
         public static IQbservable<TSource[]> ForkJoin<TSource>(this IQbservableProvider provider, params IObservable<TSource>[] sources)
@@ -200,11 +200,11 @@ namespace System.Reactive.Linq
         /// <summary>
         /// Runs all observable sequences in the enumerable sources sequence in parallel and collect their last elements.
         /// </summary>
-        /// <param name="provider">Query provider used to construct the IQbservable&lt;T&gt; data source.</param>
+        /// <param name="provider">Query provider used to construct the <see cref="IQbservable{T}"/> data source.</param>
         /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
         /// <param name="sources">Observable sequence to collect the last elements for.</param>
         /// <returns>An observable sequence with an array collecting the last elements of all the input sequences.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="sources" /> is null.</exception>
         [Experimental]
         public static IQbservable<TSource[]> ForkJoin<TSource>(this IQbservableProvider provider, IEnumerable<IObservable<TSource>> sources)
@@ -240,7 +240,7 @@ namespace System.Reactive.Linq
         /// <param name="second">Second observable sequence.</param>
         /// <param name="resultSelector">Result selector function to invoke with the last elements of both sequences.</param>
         /// <returns>An observable sequence with the result of calling the selector function with the last elements of both input sequences.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="first" /> or <paramref name="second" /> or <paramref name="resultSelector" /> is null.</exception>
         [Experimental]
         public static IQbservable<TResult> ForkJoin<TSource1, TSource2, TResult>(this IQbservable<TSource1> first, IObservable<TSource2> second, Expression<Func<TSource1, TSource2, TResult>> resultSelector)
@@ -278,7 +278,7 @@ namespace System.Reactive.Linq
         /// <param name="source">Source sequence that will be shared in the selector function.</param>
         /// <param name="selector">Selector function which can use the source sequence as many times as needed, without sharing subscriptions to the source sequence.</param>
         /// <returns>An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.</returns>
-        /// <exception cref="T:System.ArgumentNullException">
+        /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         [Experimental]
         public static IQbservable<TResult> Let<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<IObservable<TSource>, IObservable<TResult>>> selector)

Rx.NET/Source/src/System.Reactive/NamespaceDocs.cs

@@ -43,7 +43,7 @@ namespace System.Reactive.Linq
 {
     /// <summary>
     /// The <b>System.Reactive.Linq</b> namespace contains interfaces and classes that support expressing queries over observable sequences, using Language Integrated Query (LINQ).
-    /// Query operators are made available as extension methods for IObservable&lt;T&gt; and IQbservable&lt;T&gt; defined on the Observable and Qbservable classes, respectively.
+    /// Query operators are made available as extension methods for <see cref="IObservable{T}"/> and <see cref="IQbservable{T}"/> defined on the Observable and Qbservable classes, respectively.
     /// </summary>
     [System.Runtime.CompilerServices.CompilerGeneratedAttribute]
     class NamespaceDoc
@@ -54,7 +54,7 @@ namespace System.Reactive.Linq
 namespace System.Reactive.Subjects
 {
     /// <summary>
-    /// The <b>System.Reactive.Subjects</b> namespace contains interfaces and classes to represent subjects, which are objects implementing both IObservable&lt;T&gt; and IObserver&lt;T&gt;.
+    /// The <b>System.Reactive.Subjects</b> namespace contains interfaces and classes to represent subjects, which are objects implementing both <see cref="IObservable{T}"/> and <see cref="IObserver{T}"/>.
     /// Subjects are often used as sources of events, allowing one party to raise events and allowing another party to write queries over the event stream. Because of their ability to
     /// have multiple registered observers, subjects are also used as a facility to provide multicast behavior for event streams in queries.
     /// </summary>

Rx.NET/Source/src/System.Reactive/Notification.cs

@@ -480,27 +480,27 @@ namespace System.Reactive
         }
 
         /// <summary>
-        /// Determines whether the current Notification&lt;T&gt; object has the same observer message payload as a specified Notification&lt;T&gt; value.
+        /// Determines whether the current <see cref="Notification{T}"/> object has the same observer message payload as a specified <see cref="Notification{T}"/> value.
         /// </summary>
-        /// <param name="other">An object to compare to the current Notification&lt;T&gt; object.</param>
-        /// <returns>true if both Notification&lt;T&gt; objects have the same observer message payload; otherwise, false.</returns>
+        /// <param name="other">An object to compare to the current <see cref="Notification{T}"/> object.</param>
+        /// <returns>true if both <see cref="Notification{T}"/> objects have the same observer message payload; otherwise, false.</returns>
         /// <remarks>
-        /// Equality of Notification&lt;T&gt; objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any).
-        /// This means two Notification&lt;T&gt; objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method.
-        /// In case one wants to determine whether two Notification&lt;T&gt; objects represent the same observer method call, use Object.ReferenceEquals identity equality instead.
+        /// Equality of <see cref="Notification{T}"/> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any).
+        /// This means two <see cref="Notification{T}"/> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method.
+        /// In case one wants to determine whether two <see cref="Notification{T}"/> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead.
         /// </remarks>
         public abstract bool Equals(Notification<T> other);
 
         /// <summary>
-        /// Determines whether the two specified Notification&lt;T&gt; objects have the same observer message payload.
+        /// Determines whether the two specified <see cref="Notification{T}"/> objects have the same observer message payload.
         /// </summary>
-        /// <param name="left">The first Notification&lt;T&gt; to compare, or null.</param>
-        /// <param name="right">The second Notification&lt;T&gt; to compare, or null.</param>
-        /// <returns>true if the first Notification&lt;T&gt; value has the same observer message payload as the second Notification&lt;T&gt; value; otherwise, false.</returns>
+        /// <param name="left">The first <see cref="Notification{T}"/> to compare, or null.</param>
+        /// <param name="right">The second <see cref="Notification{T}"/> to compare, or null.</param>
+        /// <returns>true if the first <see cref="Notification{T}"/> value has the same observer message payload as the second <see cref="Notification{T}"/> value; otherwise, false.</returns>
         /// <remarks>
-        /// Equality of Notification&lt;T&gt; objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any).
-        /// This means two Notification&lt;T&gt; objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method.
-        /// In case one wants to determine whether two Notification&lt;T&gt; objects represent the same observer method call, use Object.ReferenceEquals identity equality instead.
+        /// Equality of <see cref="Notification{T}"/> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any).
+        /// This means two <see cref="Notification{T}"/> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method.
+        /// In case one wants to determine whether two <see cref="Notification{T}"/> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead.
         /// </remarks>
         public static bool operator ==(Notification<T> left, Notification<T> right)
         {
@@ -514,15 +514,15 @@ namespace System.Reactive
         }
 
         /// <summary>
-        /// Determines whether the two specified Notification&lt;T&gt; objects have a different observer message payload.
+        /// Determines whether the two specified <see cref="Notification{T}"/> objects have a different observer message payload.
         /// </summary>
-        /// <param name="left">The first Notification&lt;T&gt; to compare, or null.</param>
-        /// <param name="right">The second Notification&lt;T&gt; to compare, or null.</param>
-        /// <returns>true if the first Notification&lt;T&gt; value has a different observer message payload as the second Notification&lt;T&gt; value; otherwise, false.</returns>
+        /// <param name="left">The first <see cref="Notification{T}"/> to compare, or null.</param>
+        /// <param name="right">The second <see cref="Notification{T}"/> to compare, or null.</param>
+        /// <returns>true if the first <see cref="Notification{T}"/> value has a different observer message payload as the second <see cref="Notification{T}"/> value; otherwise, false.</returns>
         /// <remarks>
-        /// Equality of Notification&lt;T&gt; objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any).
-        /// This means two Notification&lt;T&gt; objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method.
-        /// In case one wants to determine whether two Notification&lt;T&gt; objects represent a different observer method call, use Object.ReferenceEquals identity equality instead.
+        /// Equality of <see cref="Notification{T}"/> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any).
+        /// This means two <see cref="Notification{T}"/> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method.
+        /// In case one wants to determine whether two <see cref="Notification{T}"/> objects represent a different observer method call, use Object.ReferenceEquals identity equality instead.
         /// </remarks>
         public static bool operator !=(Notification<T> left, Notification<T> right)
         {
@@ -530,14 +530,14 @@ namespace System.Reactive
         }
 
         /// <summary>
-        /// Determines whether the specified System.Object is equal to the current Notification&lt;T&gt;.
+        /// Determines whether the specified System.Object is equal to the current <see cref="Notification{T}"/>.
         /// </summary>
-        /// <param name="obj">The System.Object to compare with the current Notification&lt;T&gt;.</param>
-        /// <returns>true if the specified System.Object is equal to the current Notification&lt;T&gt;; otherwise, false.</returns>
+        /// <param name="obj">The System.Object to compare with the current <see cref="Notification{T}"/>.</param>
+        /// <returns>true if the specified System.Object is equal to the current <see cref="Notification{T}"/>; otherwise, false.</returns>
         /// <remarks>
-        /// Equality of Notification&lt;T&gt; objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any).
-        /// This means two Notification&lt;T&gt; objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method.
-        /// In case one wants to determine whether two Notification&lt;T&gt; objects represent the same observer method call, use Object.ReferenceEquals identity equality instead.
+        /// Equality of <see cref="Notification{T}"/> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any).
+        /// This means two <see cref="Notification{T}"/> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method.
+        /// In case one wants to determine whether two <see cref="Notification{T}"/> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead.
         /// </remarks>
         public override bool Equals(object obj)
         {

Rx.NET/Source/src/System.Reactive/ObservableBase.cs

@@ -8,7 +8,7 @@ using System.Reactive.Disposables;
 namespace System.Reactive
 {
     /// <summary>
-    /// Abstract base class for implementations of the IObservable&lt;T&gt; interface.
+    /// Abstract base class for implementations of the <see cref="IObservable{T}"/> interface.
     /// </summary>
     /// <remarks>
     /// If you don't need a named type to create an observable sequence (i.e. you rather need

Rx.NET/Source/src/System.Reactive/ObserverBase.cs

@@ -7,7 +7,7 @@ using System.Threading;
 namespace System.Reactive
 {
     /// <summary>
-    /// Abstract base class for implementations of the IObserver&lt;T&gt; interface.
+    /// Abstract base class for implementations of the <see cref="IObserver{T}"/> interface.
     /// </summary>
     /// <remarks>This base class enforces the grammar of observers where OnError and OnCompleted are terminal messages.</remarks>
     /// <typeparam name="T">The type of the elements in the sequence.</typeparam>

Rx.NET/Source/src/System.Reactive/Platforms/Desktop/Concurrency/ControlScheduler.cs

@@ -21,7 +21,7 @@ namespace System.Reactive.Concurrency
         /// <param name="control">Windows Forms control to get the message loop from.</param>
         /// <exception cref="ArgumentNullException"><paramref name="control"/> is null.</exception>
         /// <remarks>
-        /// This scheduler type is typically used indirectly through the <see cref="System.Reactive.Linq.ControlObservable.ObserveOn&lt;TSource&gt;"/> and <see cref="System.Reactive.Linq.ControlObservable.SubscribeOn&lt;TSource&gt;"/> method overloads that take a Windows Forms control.
+        /// This scheduler type is typically used indirectly through the <see cref="System.Reactive.Linq.ControlObservable.ObserveOn{TSource}"/> and <see cref="System.Reactive.Linq.ControlObservable.SubscribeOn{TSource}"/> method overloads that take a Windows Forms control.
         /// </remarks>
         public ControlScheduler(Control control)
         {

Rx.NET/Source/src/System.Reactive/Platforms/UWP/Linq/WindowsObservable.StandardSequenceOperators.cs

@@ -20,7 +20,7 @@ namespace System.Reactive.Linq
         /// <param name="selector">A transform function to apply to each element.</param>
         /// <returns>An observable sequence whose elements are the result of the asynchronous operations executed for each element of the input sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>This overload supports composition of observable sequences and Windows Runtime asynchronous operations, without requiring manual conversion of the asynchronous operations to observable sequences using <see cref="AsyncInfoObservableExtensions.ToObservable&lt;TResult&gt;(IAsyncOperation&lt;TResult&gt;)"/>.</remarks>
+        /// <remarks>This overload supports composition of observable sequences and Windows Runtime asynchronous operations, without requiring manual conversion of the asynchronous operations to observable sequences using <see cref="AsyncInfoObservableExtensions.ToObservable{TResult}(IAsyncOperation{TResult})"/>.</remarks>
         public static IObservable<TResult> SelectMany<TSource, TResult>(this IObservable<TSource> source, Func<TSource, IAsyncOperation<TResult>> selector)
         {
             if (source == null)
@@ -41,7 +41,7 @@ namespace System.Reactive.Linq
         /// <param name="selector">A transform function to apply to each element.</param>
         /// <returns>An observable sequence whose elements are the result of the asynchronous operations executed for each element of the input sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>This overload supports composition of observable sequences and Windows Runtime asynchronous operations, without requiring manual conversion of the asynchronous operations to observable sequences using <see cref="AsyncInfoObservableExtensions.ToObservable&lt;TResult&gt;(IAsyncOperation&lt;TResult&gt;)"/>.</remarks>
+        /// <remarks>This overload supports composition of observable sequences and Windows Runtime asynchronous operations, without requiring manual conversion of the asynchronous operations to observable sequences using <see cref="AsyncInfoObservableExtensions.ToObservable{TResult}(IAsyncOperation{TResult})"/>.</remarks>
         public static IObservable<TResult> SelectMany<TSource, TResult, TProgress>(this IObservable<TSource> source, Func<TSource, IAsyncOperationWithProgress<TResult, TProgress>> selector)
         {
             if (source == null)
@@ -63,7 +63,7 @@ namespace System.Reactive.Linq
         /// <param name="resultSelector">A transform function to apply to each element of the intermediate sequence.</param>
         /// <returns>An observable sequence whose elements are the result of obtaining an asynchronous operation for each element of the input sequence and then mapping the asynchronous operation's result and its corresponding source element to a result element.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="asyncOperationSelector"/> or <paramref name="resultSelector"/> is null.</exception>
-        /// <remarks>This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and Windows Runtime asynchronous operations, without requiring manual conversion of the asynchronous operations to observable sequences using <see cref="AsyncInfoObservableExtensions.ToObservable&lt;TResult&gt;(IAsyncOperation&lt;TResult&gt;)"/>.</remarks>
+        /// <remarks>This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and Windows Runtime asynchronous operations, without requiring manual conversion of the asynchronous operations to observable sequences using <see cref="AsyncInfoObservableExtensions.ToObservable{TResult}(IAsyncOperation{TResult})"/>.</remarks>
         public static IObservable<TResult> SelectMany<TSource, TAsyncOperationResult, TResult>(this IObservable<TSource> source, Func<TSource, IAsyncOperation<TAsyncOperationResult>> asyncOperationSelector, Func<TSource, TAsyncOperationResult, TResult> resultSelector)
         {
             if (source == null)
@@ -88,7 +88,7 @@ namespace System.Reactive.Linq
         /// <param name="resultSelector">A transform function to apply to each element of the intermediate sequence.</param>
         /// <returns>An observable sequence whose elements are the result of obtaining an asynchronous operation for each element of the input sequence and then mapping the asynchronous operation's result and its corresponding source element to a result element.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="asyncOperationSelector"/> or <paramref name="resultSelector"/> is null.</exception>
-        /// <remarks>This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and Windows Runtime asynchronous operations, without requiring manual conversion of the asynchronous operations to observable sequences using <see cref="AsyncInfoObservableExtensions.ToObservable&lt;TResult&gt;(IAsyncOperation&lt;TResult&gt;)"/>.</remarks>
+        /// <remarks>This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and Windows Runtime asynchronous operations, without requiring manual conversion of the asynchronous operations to observable sequences using <see cref="AsyncInfoObservableExtensions.ToObservable{TResult}(IAsyncOperation{TResult})"/>.</remarks>
         public static IObservable<TResult> SelectMany<TSource, TAsyncOperationResult, TAsyncOperationProgress, TResult>(this IObservable<TSource> source, Func<TSource, IAsyncOperationWithProgress<TAsyncOperationResult, TAsyncOperationProgress>> asyncOperationSelector, Func<TSource, TAsyncOperationResult, TResult> resultSelector)
         {
             if (source == null)

Rx.NET/Source/src/System.Reactive/Platforms/Windows/Concurrency/CoreDispatcherScheduler.cs

@@ -16,7 +16,7 @@ namespace System.Reactive.Concurrency
     /// Represents an object that schedules units of work on a Windows.UI.Core.CoreDispatcher.
     /// </summary>
     /// <remarks>
-    /// This scheduler type is typically used indirectly through the <see cref="System.Reactive.Linq.DispatcherObservable.ObserveOnDispatcher&lt;TSource&gt;(IObservable&lt;TSource&gt;)"/> and <see cref="System.Reactive.Linq.DispatcherObservable.SubscribeOnDispatcher&lt;TSource&gt;(IObservable&lt;TSource&gt;)"/> methods that use the current Dispatcher.
+    /// This scheduler type is typically used indirectly through the <see cref="System.Reactive.Linq.DispatcherObservable.ObserveOnDispatcher{TSource}(IObservable{TSource})"/> and <see cref="System.Reactive.Linq.DispatcherObservable.SubscribeOnDispatcher{TSource}(IObservable{TSource})"/> methods that use the current Dispatcher.
     /// </remarks>
     [CLSCompliant(false)]
     public sealed class CoreDispatcherScheduler : LocalScheduler, ISchedulerPeriodic

Rx.NET/Source/src/System.Reactive/Platforms/Windows/Concurrency/DispatcherScheduler.cs

@@ -12,7 +12,7 @@ namespace System.Reactive.Concurrency
     /// Represents an object that schedules units of work on a <see cref="System.Windows.Threading.Dispatcher"/>.
     /// </summary>
     /// <remarks>
-    /// This scheduler type is typically used indirectly through the <see cref="System.Reactive.Linq.DispatcherObservable.ObserveOnDispatcher&lt;TSource&gt;(IObservable&lt;TSource&gt;)"/> and <see cref="System.Reactive.Linq.DispatcherObservable.SubscribeOnDispatcher&lt;TSource&gt;(IObservable&lt;TSource&gt;)"/> methods that use the Dispatcher on the calling thread.
+    /// This scheduler type is typically used indirectly through the <see cref="System.Reactive.Linq.DispatcherObservable.ObserveOnDispatcher{TSource}(IObservable{TSource})"/> and <see cref="System.Reactive.Linq.DispatcherObservable.SubscribeOnDispatcher{TSource}(IObservable{TSource})"/> methods that use the Dispatcher on the calling thread.
     /// </remarks>
     public class DispatcherScheduler : LocalScheduler, ISchedulerPeriodic
     {

Rx.NET/Source/src/System.Reactive/Subjects/BehaviorSubject.cs

@@ -28,7 +28,7 @@ namespace System.Reactive.Subjects
         #region Constructors
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="System.Reactive.Subjects.BehaviorSubject&lt;T&gt;"/> class which creates a subject that caches its last value and starts with the specified value.
+        /// Initializes a new instance of the <see cref="BehaviorSubject{T}"/> class which creates a subject that caches its last value and starts with the specified value.
         /// </summary>
         /// <param name="value">Initial value sent to observers when no other value has been received by the subject yet.</param>
         public BehaviorSubject(T value)

Rx.NET/Source/src/System.Reactive/Subjects/ReplaySubject.cs

@@ -30,7 +30,7 @@ namespace System.Reactive.Subjects
         #region All
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;" /> class.
+        /// Initializes a new instance of the <see cref="ReplaySubject{T}" /> class.
         /// </summary>
         public ReplaySubject()
             : this(int.MaxValue)
@@ -38,7 +38,7 @@ namespace System.Reactive.Subjects
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;" /> class with the specified scheduler.
+        /// Initializes a new instance of the <see cref="ReplaySubject{T}" /> class with the specified scheduler.
         /// </summary>
         /// <param name="scheduler">Scheduler the observers are invoked on.</param>
         /// <exception cref="ArgumentNullException"><paramref name="scheduler"/> is null.</exception>
@@ -52,7 +52,7 @@ namespace System.Reactive.Subjects
         #region Count
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;" /> class with the specified buffer size.
+        /// Initializes a new instance of the <see cref="ReplaySubject{T}" /> class with the specified buffer size.
         /// </summary>
         /// <param name="bufferSize">Maximum element count of the replay buffer.</param>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="bufferSize"/> is less than zero.</exception>
@@ -73,7 +73,7 @@ namespace System.Reactive.Subjects
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;" /> class with the specified buffer size and scheduler.
+        /// Initializes a new instance of the <see cref="ReplaySubject{T}" /> class with the specified buffer size and scheduler.
         /// </summary>
         /// <param name="bufferSize">Maximum element count of the replay buffer.</param>
         /// <param name="scheduler">Scheduler the observers are invoked on.</param>
@@ -89,7 +89,7 @@ namespace System.Reactive.Subjects
         #region Time
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;" /> class with the specified window.
+        /// Initializes a new instance of the <see cref="ReplaySubject{T}" /> class with the specified window.
         /// </summary>
         /// <param name="window">Maximum time length of the replay buffer.</param>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="window"/> is less than TimeSpan.Zero.</exception>
@@ -99,7 +99,7 @@ namespace System.Reactive.Subjects
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;" /> class with the specified window and scheduler.
+        /// Initializes a new instance of the <see cref="ReplaySubject{T}" /> class with the specified window and scheduler.
         /// </summary>
         /// <param name="window">Maximum time length of the replay buffer.</param>
         /// <param name="scheduler">Scheduler the observers are invoked on.</param>
@@ -115,7 +115,7 @@ namespace System.Reactive.Subjects
         #region Count & Time
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;" /> class with the specified buffer size and window.
+        /// Initializes a new instance of the <see cref="ReplaySubject{T}" /> class with the specified buffer size and window.
         /// </summary>
         /// <param name="bufferSize">Maximum element count of the replay buffer.</param>
         /// <param name="window">Maximum time length of the replay buffer.</param>
@@ -126,7 +126,7 @@ namespace System.Reactive.Subjects
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;" /> class with the specified buffer size, window and scheduler.
+        /// Initializes a new instance of the <see cref="ReplaySubject{T}" /> class with the specified buffer size, window and scheduler.
         /// </summary>
         /// <param name="bufferSize">Maximum element count of the replay buffer.</param>
         /// <param name="window">Maximum time length of the replay buffer.</param>
@@ -219,7 +219,7 @@ namespace System.Reactive.Subjects
         #region IDisposable implementation
 
         /// <summary>
-        /// Releases all resources used by the current instance of the <see cref="System.Reactive.Subjects.ReplaySubject&lt;T&gt;"/> class and unsubscribe all observers.
+        /// Releases all resources used by the current instance of the <see cref="ReplaySubject{T}"/> class and unsubscribe all observers.
         /// </summary>
         public override void Dispose()
         {

Rx.NET/Source/src/System.Reactive/Subjects/Subject.cs

@@ -238,7 +238,7 @@ namespace System.Reactive.Subjects
         #region IDisposable implementation
 
         /// <summary>
-        /// Releases all resources used by the current instance of the <see cref="System.Reactive.Subjects.Subject&lt;T&gt;"/> class and unsubscribes all observers.
+        /// Releases all resources used by the current instance of the <see cref="Subject{T}"/> class and unsubscribes all observers.
         /// </summary>
         public override void Dispose()
         {

Rx.NET/Source/src/System.Reactive/TimeInterval.cs

@@ -48,42 +48,42 @@ namespace System.Reactive
         }
 
         /// <summary>
-        /// Determines whether the current TimeInterval&lt;T&gt; value has the same Value and Interval as a specified TimeInterval&lt;T&gt; value.
+        /// Determines whether the current <see cref="TimeInterval{T}"/> value has the same Value and Interval as a specified <see cref="TimeInterval{T}"/> value.
         /// </summary>
-        /// <param name="other">An object to compare to the current TimeInterval&lt;T&gt; value.</param>
-        /// <returns>true if both TimeInterval&lt;T&gt; values have the same Value and Interval; otherwise, false.</returns>
+        /// <param name="other">An object to compare to the current <see cref="TimeInterval{T}"/> value.</param>
+        /// <returns>true if both <see cref="TimeInterval{T}"/> values have the same Value and Interval; otherwise, false.</returns>
         public bool Equals(TimeInterval<T> other)
         {
             return other.Interval.Equals(Interval) && EqualityComparer<T>.Default.Equals(Value, other.Value);
         }
 
         /// <summary>
-        /// Determines whether the two specified TimeInterval&lt;T&gt; values have the same Value and Interval.
+        /// Determines whether the two specified <see cref="TimeInterval{T}"/> values have the same Value and Interval.
         /// </summary>
-        /// <param name="first">The first TimeInterval&lt;T&gt; value to compare.</param>
-        /// <param name="second">The second TimeInterval&lt;T&gt; value to compare.</param>
-        /// <returns>true if the first TimeInterval&lt;T&gt; value has the same Value and Interval as the second TimeInterval&lt;T&gt; value; otherwise, false.</returns>
+        /// <param name="first">The first <see cref="TimeInterval{T}"/> value to compare.</param>
+        /// <param name="second">The second <see cref="TimeInterval{T}"/> value to compare.</param>
+        /// <returns>true if the first <see cref="TimeInterval{T}"/> value has the same Value and Interval as the second <see cref="TimeInterval{T}"/> value; otherwise, false.</returns>
         public static bool operator ==(TimeInterval<T> first, TimeInterval<T> second)
         {
             return first.Equals(second);
         }
 
         /// <summary>
-        /// Determines whether the two specified TimeInterval&lt;T&gt; values don't have the same Value and Interval.
+        /// Determines whether the two specified <see cref="TimeInterval{T}"/> values don't have the same Value and Interval.
         /// </summary>
-        /// <param name="first">The first TimeInterval&lt;T&gt; value to compare.</param>
-        /// <param name="second">The second TimeInterval&lt;T&gt; value to compare.</param>
-        /// <returns>true if the first TimeInterval&lt;T&gt; value has a different Value or Interval as the second TimeInterval&lt;T&gt; value; otherwise, false.</returns>
+        /// <param name="first">The first <see cref="TimeInterval{T}"/> value to compare.</param>
+        /// <param name="second">The second <see cref="TimeInterval{T}"/> value to compare.</param>
+        /// <returns>true if the first <see cref="TimeInterval{T}"/> value has a different Value or Interval as the second <see cref="TimeInterval{T}"/> value; otherwise, false.</returns>
         public static bool operator !=(TimeInterval<T> first, TimeInterval<T> second)
         {
             return !first.Equals(second);
         }
 
         /// <summary>
-        /// Determines whether the specified System.Object is equal to the current TimeInterval&lt;T&gt;.
+        /// Determines whether the specified System.Object is equal to the current <see cref="TimeInterval{T}"/>.
         /// </summary>
-        /// <param name="obj">The System.Object to compare with the current TimeInterval&lt;T&gt;.</param>
-        /// <returns>true if the specified System.Object is equal to the current TimeInterval&lt;T&gt;; otherwise, false.</returns>
+        /// <param name="obj">The System.Object to compare with the current <see cref="TimeInterval{T}"/>.</param>
+        /// <returns>true if the specified System.Object is equal to the current <see cref="TimeInterval{T}"/>; otherwise, false.</returns>
         public override bool Equals(object obj)
         {
             if (!(obj is TimeInterval<T>))
@@ -94,9 +94,9 @@ namespace System.Reactive
         }
 
         /// <summary>
-        /// Returns the hash code for the current TimeInterval&lt;T&gt; value.
+        /// Returns the hash code for the current <see cref="TimeInterval{T}"/> value.
         /// </summary>
-        /// <returns>A hash code for the current TimeInterval&lt;T&gt; value.</returns>
+        /// <returns>A hash code for the current <see cref="TimeInterval{T}"/> value.</returns>
         public override int GetHashCode()
         {
             var valueHashCode = Value == null ? 1963 : Value.GetHashCode();
@@ -105,9 +105,9 @@ namespace System.Reactive
         }
 
         /// <summary>
-        /// Returns a string representation of the current TimeInterval&lt;T&gt; value.
+        /// Returns a string representation of the current <see cref="TimeInterval{T}"/> value.
         /// </summary>
-        /// <returns>String representation of the current TimeInterval&lt;T&gt; value.</returns>
+        /// <returns>String representation of the current <see cref="TimeInterval{T}"/> value.</returns>
         public override string ToString()
         {
             return String.Format(CultureInfo.CurrentCulture, "{0}@{1}", Value, Interval);

Rx.NET/Source/src/System.Reactive/Timestamped.cs

@@ -49,42 +49,42 @@ namespace System.Reactive
         }
 
         /// <summary>
-        /// Determines whether the current Timestamped&lt;T&gt; value has the same Value and Timestamp as a specified Timestamped&lt;T&gt; value.
+        /// Determines whether the current <see cref="Timestamped{T}" /> value has the same Value and Timestamp as a specified <see cref="Timestamped{T}" /> value.
         /// </summary>
-        /// <param name="other">An object to compare to the current Timestamped&lt;T&gt; value.</param>
-        /// <returns>true if both Timestamped&lt;T&gt; values have the same Value and Timestamp; otherwise, false.</returns>
+        /// <param name="other">An object to compare to the current <see cref="Timestamped{T}" /> value.</param>
+        /// <returns>true if both <see cref="Timestamped{T}" /> values have the same Value and Timestamp; otherwise, false.</returns>
         public bool Equals(Timestamped<T> other)
         {
             return other.Timestamp.Equals(Timestamp) && EqualityComparer<T>.Default.Equals(Value, other.Value);
         }
 
         /// <summary>
-        /// Determines whether the two specified Timestamped&lt;T&gt; values have the same Value and Timestamp.
+        /// Determines whether the two specified <see cref="Timestamped{T}" /> values have the same Value and Timestamp.
         /// </summary>
-        /// <param name="first">The first Timestamped&lt;T&gt; value to compare.</param>
-        /// <param name="second">The second Timestamped&lt;T&gt; value to compare.</param>
-        /// <returns>true if the first Timestamped&lt;T&gt; value has the same Value and Timestamp as the second Timestamped&lt;T&gt; value; otherwise, false.</returns>
+        /// <param name="first">The first <see cref="Timestamped{T}" /> value to compare.</param>
+        /// <param name="second">The second <see cref="Timestamped{T}" /> value to compare.</param>
+        /// <returns>true if the first <see cref="Timestamped{T}" /> value has the same Value and Timestamp as the second <see cref="Timestamped{T}" /> value; otherwise, false.</returns>
         public static bool operator ==(Timestamped<T> first, Timestamped<T> second)
         {
             return first.Equals(second);
         }
 
         /// <summary>
-        /// Determines whether the two specified Timestamped&lt;T&gt; values don't have the same Value and Timestamp.
+        /// Determines whether the two specified <see cref="Timestamped{T}" /> values don't have the same Value and Timestamp.
         /// </summary>
-        /// <param name="first">The first Timestamped&lt;T&gt; value to compare.</param>
-        /// <param name="second">The second Timestamped&lt;T&gt; value to compare.</param>
-        /// <returns>true if the first Timestamped&lt;T&gt; value has a different Value or Timestamp as the second Timestamped&lt;T&gt; value; otherwise, false.</returns>
+        /// <param name="first">The first <see cref="Timestamped{T}" /> value to compare.</param>
+        /// <param name="second">The second <see cref="Timestamped{T}" /> value to compare.</param>
+        /// <returns>true if the first <see cref="Timestamped{T}" /> value has a different Value or Timestamp as the second <see cref="Timestamped{T}" /> value; otherwise, false.</returns>
         public static bool operator !=(Timestamped<T> first, Timestamped<T> second)
         {
             return !first.Equals(second);
         }
 
         /// <summary>
-        /// Determines whether the specified System.Object is equal to the current Timestamped&lt;T&gt;.
+        /// Determines whether the specified System.Object is equal to the current <see cref="Timestamped{T}" />.
         /// </summary>
-        /// <param name="obj">The System.Object to compare with the current Timestamped&lt;T&gt;.</param>
-        /// <returns>true if the specified System.Object is equal to the current Timestamped&lt;T&gt;; otherwise, false.</returns>
+        /// <param name="obj">The System.Object to compare with the current <see cref="Timestamped{T}" />.</param>
+        /// <returns>true if the specified System.Object is equal to the current <see cref="Timestamped{T}" />; otherwise, false.</returns>
         public override bool Equals(object obj)
         {
             if (!(obj is Timestamped<T>))
@@ -95,9 +95,9 @@ namespace System.Reactive
         }
 
         /// <summary>
-        /// Returns the hash code for the current Timestamped&lt;T&gt; value.
+        /// Returns the hash code for the current <see cref="Timestamped{T}" /> value.
         /// </summary>
-        /// <returns>A hash code for the current Timestamped&lt;T&gt; value.</returns>
+        /// <returns>A hash code for the current <see cref="Timestamped{T}" /> value.</returns>
         public override int GetHashCode()
         {
             var valueHashCode = Value == null ? 1979 : Value.GetHashCode();
@@ -106,9 +106,9 @@ namespace System.Reactive
         }
 
         /// <summary>
-        /// Returns a string representation of the current Timestamped&lt;T&gt; value.
+        /// Returns a string representation of the current <see cref="Timestamped{T}" /> value.
         /// </summary>
-        /// <returns>String representation of the current Timestamped&lt;T&gt; value.</returns>
+        /// <returns>String representation of the current <see cref="Timestamped{T}" /> value.</returns>
         public override string ToString()
         {
             return String.Format(CultureInfo.CurrentCulture, "{0}@{1}", Value, Timestamp);
@@ -116,12 +116,12 @@ namespace System.Reactive
     }
 
     /// <summary>
-    /// A helper class with a factory method for creating Timestamped&lt;T&gt; instances.
+    /// A helper class with a factory method for creating <see cref="Timestamped{T}" /> instances.
     /// </summary>
     public static class Timestamped
     {
         /// <summary>
-        /// Creates an instance of a Timestamped&lt;T&gt;.  This is syntactic sugar that uses type inference
+        /// Creates an instance of a <see cref="Timestamped{T}" />.  This is syntactic sugar that uses type inference
         /// to avoid specifying a type in a constructor call, which is very useful when using anonymous types.
         /// </summary>
         /// <param name="value">The value to be annotated with a timestamp.</param>