Fixing XML doc style.

Ix.NET/Source/System.Interactive/System/Linq/Operators/Buffer.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Generates a sequence of non-overlapping adjacent buffers over the source sequence.
+        /// Generates a sequence of non-overlapping adjacent buffers over the source sequence.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
@@ -26,7 +26,7 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Generates a sequence of buffers over the source sequence, with specified length and possible overlap.
+        /// Generates a sequence of buffers over the source sequence, with specified length and possible overlap.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Case.cs

@@ -12,7 +12,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Returns a sequence from a dictionary based on the result of evaluating a selector function.
+        /// Returns a sequence from a dictionary based on the result of evaluating a selector function.
         /// </summary>
         /// <typeparam name="TValue">Type of the selector value.</typeparam>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>
@@ -30,16 +30,16 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Returns a sequence from a dictionary based on the result of evaluating a selector function, also specifying a
-        ///     default sequence.
+        /// Returns a sequence from a dictionary based on the result of evaluating a selector function, also specifying a
+        /// default sequence.
         /// </summary>
         /// <typeparam name="TValue">Type of the selector value.</typeparam>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>
         /// <param name="selector">Selector function used to pick a sequence from the given sources.</param>
         /// <param name="sources">Dictionary mapping selector values onto resulting sequences.</param>
         /// <param name="defaultSource">
-        ///     Default sequence to return in case there's no corresponding source for the computed
-        ///     selector value.
+        /// Default sequence to return in case there's no corresponding source for the computed
+        /// selector value.
         /// </param>
         /// <returns>The source sequence corresponding with the evaluated selector value; otherwise, the default source.</returns>
         public static IEnumerable<TResult> Case<TValue, TResult>(Func<TValue> selector, IDictionary<TValue, IEnumerable<TResult>> sources, IEnumerable<TResult> defaultSource)

Ix.NET/Source/System.Interactive/System/Linq/Operators/Catch.cs

@@ -9,8 +9,8 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Creates a sequence that corresponds to the source sequence, concatenating it with the sequence resulting from
-        ///     calling an exception handler function in case of an error.
+        /// Creates a sequence that corresponds to the source sequence, concatenating it with the sequence resulting from
+        /// calling an exception handler function in case of an error.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <typeparam name="TException">Exception type to catch.</typeparam>
@@ -29,7 +29,7 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Creates a sequence by concatenating source sequences until a source sequence completes successfully.
+        /// Creates a sequence by concatenating source sequences until a source sequence completes successfully.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="sources">Source sequences.</param>
@@ -43,7 +43,7 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Creates a sequence by concatenating source sequences until a source sequence completes successfully.
+        /// Creates a sequence by concatenating source sequences until a source sequence completes successfully.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="sources">Source sequences.</param>
@@ -57,7 +57,7 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Creates a sequence that returns the elements of the first sequence, switching to the second in case of an error.
+        /// Creates a sequence that returns the elements of the first sequence, switching to the second in case of an error.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="first">First sequence.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Concat.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Concatenates the input sequences.
+        /// Concatenates the input sequences.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="sources">Source sequences.</param>
@@ -23,7 +23,7 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Concatenates the input sequences.
+        /// Concatenates the input sequences.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="sources">Source sequences.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Create.cs

@@ -10,7 +10,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Creates an enumerable sequence based on an enumerator factory function.
+        /// Creates an enumerable sequence based on an enumerator factory function.
         /// </summary>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>
         /// <param name="getEnumerator">Enumerator factory function.</param>
@@ -24,12 +24,12 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Creates an enumerable sequence based on an asynchronous method that provides a yielder.
+        /// Creates an enumerable sequence based on an asynchronous method that provides a yielder.
         /// </summary>
         /// <typeparam name="T">Result sequence element type.</typeparam>
         /// <param name="create">
-        ///     Delegate implementing an asynchronous method that can use the specified yielder to yield return
-        ///     values.
+        /// Delegate implementing an asynchronous method that can use the specified yielder to yield return
+        /// values.
         /// </param>
         /// <returns>Sequence that will use the asynchronous method to obtain its elements.</returns>
         public static IEnumerable<T> Create<T>(Action<IYielder<T>> create)

Ix.NET/Source/System.Interactive/System/Linq/Operators/Defer.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Creates an enumerable sequence based on an enumerable factory function.
+        /// Creates an enumerable sequence based on an enumerable factory function.
         /// </summary>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>
         /// <param name="enumerableFactory">Enumerable factory function.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Do.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Lazily invokes an action for each value in the sequence.
+        /// Lazily invokes an action for each value in the sequence.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
@@ -26,7 +26,7 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Lazily invokes an action for each value in the sequence, and executes an action for successful termination.
+        /// Lazily invokes an action for each value in the sequence, and executes an action for successful termination.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
@@ -46,7 +46,7 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Lazily invokes an action for each value in the sequence, and executes an action upon exceptional termination.
+        /// Lazily invokes an action for each value in the sequence, and executes an action upon exceptional termination.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
@@ -66,8 +66,8 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Lazily invokes an action for each value in the sequence, and executes an action upon successful or exceptional
-        ///     termination.
+        /// Lazily invokes an action for each value in the sequence, and executes an action upon successful or exceptional
+        /// termination.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
@@ -90,7 +90,7 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Lazily invokes observer methods for each value in the sequence, and upon successful or exceptional termination.
+        /// Lazily invokes observer methods for each value in the sequence, and upon successful or exceptional termination.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
@@ -107,7 +107,7 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Generates an enumerable sequence by repeating a source sequence as long as the given loop postcondition holds.
+        /// Generates an enumerable sequence by repeating a source sequence as long as the given loop postcondition holds.
         /// </summary>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>
         /// <param name="source">Source sequence to repeat while the condition evaluates true.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Expand.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Expands the sequence by recursively applying a selector function.
+        /// Expands the sequence by recursively applying a selector function.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Finally.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Creates a sequence whose termination or disposal of an enumerator causes a finally action to be executed.
+        /// Creates a sequence whose termination or disposal of an enumerator causes a finally action to be executed.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/For.cs

@@ -9,16 +9,16 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Generates a sequence by enumerating a source sequence, mapping its elements on result sequences, and concatenating
-        ///     those sequences.
+        /// Generates a sequence by enumerating a source sequence, mapping its elements on result sequences, and concatenating
+        /// those sequences.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
         /// <param name="resultSelector">Result selector to evaluate for each iteration over the source.</param>
         /// <returns>
-        ///     Sequence concatenating the inner sequences that result from evaluating the result selector on elements from
-        ///     the source.
+        /// Sequence concatenating the inner sequences that result from evaluating the result selector on elements from
+        /// the source.
         /// </returns>
         public static IEnumerable<TResult> For<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> resultSelector)
         {

Ix.NET/Source/System.Interactive/System/Linq/Operators/ForEach.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Enumerates the sequence and invokes the given action for each value in the sequence.
+        /// Enumerates the sequence and invokes the given action for each value in the sequence.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
@@ -26,7 +26,7 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Enumerates the sequence and invokes the given action for each value in the sequence.
+        /// Enumerates the sequence and invokes the given action for each value in the sequence.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Generate.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Generates a sequence by mimicking a for loop.
+        /// Generates a sequence by mimicking a for loop.
         /// </summary>
         /// <typeparam name="TState">State type.</typeparam>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Hide.cs

@@ -9,14 +9,14 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Hides the enumerable sequence object identity.
+        /// Hides the enumerable sequence object identity.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
         /// <returns>Enumerable sequence with the same behavior as the original, but hiding the source object identity.</returns>
         /// <remarks>
-        ///     AsEnumerable doesn't hide the object identity, and simply acts as a cast to the IEnumerable&lt;TSource&gt;
-        ///     interface.
+        /// AsEnumerable doesn't hide the object identity, and simply acts as a cast to the IEnumerable&lt;TSource&gt;
+        /// interface.
         /// </remarks>
         public static IEnumerable<TSource> Hide<TSource>(this IEnumerable<TSource> source)
         {

Ix.NET/Source/System.Interactive/System/Linq/Operators/If.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Returns an enumerable sequence based on the evaluation result of the given condition.
+        /// Returns an enumerable sequence based on the evaluation result of the given condition.
         /// </summary>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>
         /// <param name="condition">Condition to evaluate.</param>
@@ -29,8 +29,8 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Returns an enumerable sequence if the evaluation result of the given condition is true, otherwise returns an empty
-        ///     sequence.
+        /// Returns an enumerable sequence if the evaluation result of the given condition is true, otherwise returns an empty
+        /// sequence.
         /// </summary>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>
         /// <param name="condition">Condition to evaluate.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/IgnoreElements.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Ignores all elements in the source sequence.
+        /// Ignores all elements in the source sequence.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/IsEmpty.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Determines whether an enumerable sequence is empty.
+        /// Determines whether an enumerable sequence is empty.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Max.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Returns the maximum value in the enumerable sequence by using the specified comparer to compare values.
+        /// Returns the maximum value in the enumerable sequence by using the specified comparer to compare values.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/MaxBy.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Returns the elements with the maximum key value by using the default comparer to compare key values.
+        /// Returns the elements with the maximum key value by using the default comparer to compare key values.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <typeparam name="TKey">Key type.</typeparam>
@@ -27,7 +27,7 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Returns the elements with the minimum key value by using the specified comparer to compare key values.
+        /// Returns the elements with the minimum key value by using the specified comparer to compare key values.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <typeparam name="TKey">Key type.</typeparam>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Memoize.cs

@@ -11,27 +11,27 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Creates a buffer with a view over the source sequence, causing each enumerator to obtain access to all of the
-        ///     sequence's elements without causing multiple enumerations over the source.
+        /// Creates a buffer with a view over the source sequence, causing each enumerator to obtain access to all of the
+        /// sequence's elements without causing multiple enumerations over the source.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
         /// <returns>
-        ///     Buffer enabling each enumerator to retrieve all elements from the shared source sequence, without duplicating
-        ///     source enumeration side-effects.
+        /// Buffer enabling each enumerator to retrieve all elements from the shared source sequence, without duplicating
+        /// source enumeration side-effects.
         /// </returns>
         /// <example>
-        ///     var rng = Enumerable.Range(0, 10).Do(x => Console.WriteLine(x)).Memoize();
-        ///     var e1 = rng.GetEnumerator();
-        ///     Assert.IsTrue(e1.MoveNext());    // Prints 0
-        ///     Assert.AreEqual(0, e1.Current);
-        ///     Assert.IsTrue(e1.MoveNext());    // Prints 1
-        ///     Assert.AreEqual(1, e1.Current);
-        ///     var e2 = rng.GetEnumerator();
-        ///     Assert.IsTrue(e2.MoveNext());    // Doesn't print anything; the side-effect of Do
-        ///     Assert.AreEqual(0, e2.Current);  // has already taken place during e1's iteration.
-        ///     Assert.IsTrue(e1.MoveNext());    // Prints 2
-        ///     Assert.AreEqual(2, e1.Current);
+        /// var rng = Enumerable.Range(0, 10).Do(x => Console.WriteLine(x)).Memoize();
+        /// var e1 = rng.GetEnumerator();
+        /// Assert.IsTrue(e1.MoveNext());    // Prints 0
+        /// Assert.AreEqual(0, e1.Current);
+        /// Assert.IsTrue(e1.MoveNext());    // Prints 1
+        /// Assert.AreEqual(1, e1.Current);
+        /// var e2 = rng.GetEnumerator();
+        /// Assert.IsTrue(e2.MoveNext());    // Doesn't print anything; the side-effect of Do
+        /// Assert.AreEqual(0, e2.Current);  // has already taken place during e1's iteration.
+        /// Assert.IsTrue(e1.MoveNext());    // Prints 2
+        /// Assert.AreEqual(2, e1.Current);
         /// </example>
         public static IBuffer<TSource> Memoize<TSource>(this IEnumerable<TSource> source)
         {
@@ -42,8 +42,8 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Memoizes the source sequence within a selector function where each enumerator can get access to all of the
-        ///     sequence's elements without causing multiple enumerations over the source.
+        /// Memoizes the source sequence within a selector function where each enumerator can get access to all of the
+        /// sequence's elements without causing multiple enumerations over the source.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>
@@ -61,18 +61,18 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Creates a buffer with a view over the source sequence, causing a specified number of enumerators to obtain access
-        ///     to all of the sequence's elements without causing multiple enumerations over the source.
+        /// Creates a buffer with a view over the source sequence, causing a specified number of enumerators to obtain access
+        /// to all of the sequence's elements without causing multiple enumerations over the source.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
         /// <param name="readerCount">
-        ///     Number of enumerators that can access the underlying buffer. Once every enumerator has
-        ///     obtained an element from the buffer, the element is removed from the buffer.
+        /// Number of enumerators that can access the underlying buffer. Once every enumerator has
+        /// obtained an element from the buffer, the element is removed from the buffer.
         /// </param>
         /// <returns>
-        ///     Buffer enabling a specified number of enumerators to retrieve all elements from the shared source sequence,
-        ///     without duplicating source enumeration side-effects.
+        /// Buffer enabling a specified number of enumerators to retrieve all elements from the shared source sequence,
+        /// without duplicating source enumeration side-effects.
         /// </returns>
         public static IBuffer<TSource> Memoize<TSource>(this IEnumerable<TSource> source, int readerCount)
         {
@@ -85,19 +85,19 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Memoizes the source sequence within a selector function where a specified number of enumerators can get access to
-        ///     all of the sequence's elements without causing multiple enumerations over the source.
+        /// Memoizes the source sequence within a selector function where a specified number of enumerators can get access to
+        /// all of the sequence's elements without causing multiple enumerations over the source.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
         /// <param name="readerCount">
-        ///     Number of enumerators that can access the underlying buffer. Once every enumerator has
-        ///     obtained an element from the buffer, the element is removed from the buffer.
+        /// Number of enumerators that can access the underlying buffer. Once every enumerator has
+        /// obtained an element from the buffer, the element is removed from the buffer.
         /// </param>
         /// <param name="selector">
-        ///     Selector function with memoized access to the source sequence for a specified number of
-        ///     enumerators.
+        /// Selector function with memoized access to the source sequence for a specified number of
+        /// enumerators.
         /// </param>
         /// <returns>Sequence resulting from applying the selector function to the memoized view over the source sequence.</returns>
         public static IEnumerable<TResult> Memoize<TSource, TResult>(this IEnumerable<TSource> source, int readerCount, Func<IEnumerable<TSource>, IEnumerable<TResult>> selector)

Ix.NET/Source/System.Interactive/System/Linq/Operators/Min.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Returns the minimum value in the enumerable sequence by using the specified comparer to compare values.
+        /// Returns the minimum value in the enumerable sequence by using the specified comparer to compare values.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/MinBy.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Returns the elements with the minimum key value by using the default comparer to compare key values.
+        /// Returns the elements with the minimum key value by using the default comparer to compare key values.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <typeparam name="TKey">Key type.</typeparam>
@@ -27,7 +27,7 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Returns the elements with the minimum key value by using the specified comparer to compare key values.
+        /// Returns the elements with the minimum key value by using the specified comparer to compare key values.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <typeparam name="TKey">Key type.</typeparam>

Ix.NET/Source/System.Interactive/System/Linq/Operators/OnErrorResumeNext.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Creates a sequence that concatenates both given sequences, regardless of whether an error occurs.
+        /// Creates a sequence that concatenates both given sequences, regardless of whether an error occurs.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="first">First sequence.</param>
@@ -26,8 +26,8 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Creates a sequence that concatenates the given sequences, regardless of whether an error occurs in any of the
-        ///     sequences.
+        /// Creates a sequence that concatenates the given sequences, regardless of whether an error occurs in any of the
+        /// sequences.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="sources">Source sequences.</param>
@@ -41,8 +41,8 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Creates a sequence that concatenates the given sequences, regardless of whether an error occurs in any of the
-        ///     sequences.
+        /// Creates a sequence that concatenates the given sequences, regardless of whether an error occurs in any of the
+        /// sequences.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="sources">Source sequences.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Publish.cs

@@ -10,27 +10,27 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Creates a buffer with a view over the source sequence, causing each enumerator to obtain access to the remainder of
-        ///     the sequence from the current index in the buffer.
+        /// Creates a buffer with a view over the source sequence, causing each enumerator to obtain access to the remainder of
+        /// the sequence from the current index in the buffer.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
         /// <returns>
-        ///     Buffer enabling each enumerator to retrieve elements from the shared source sequence, starting from the index
-        ///     at the point of obtaining the enumerator.
+        /// Buffer enabling each enumerator to retrieve elements from the shared source sequence, starting from the index
+        /// at the point of obtaining the enumerator.
         /// </returns>
         /// <example>
-        ///     var rng = Enumerable.Range(0, 10).Publish();
-        ///     var e1 = rng.GetEnumerator();    // e1 has a view on the source starting from element 0
-        ///     Assert.IsTrue(e1.MoveNext());
-        ///     Assert.AreEqual(0, e1.Current);
-        ///     Assert.IsTrue(e1.MoveNext());
-        ///     Assert.AreEqual(1, e1.Current);
-        ///     var e2 = rng.GetEnumerator();
-        ///     Assert.IsTrue(e2.MoveNext());    // e2 has a view on the source starting from element 2
-        ///     Assert.AreEqual(2, e2.Current);
-        ///     Assert.IsTrue(e1.MoveNext());    // e1 continues to enumerate over its view
-        ///     Assert.AreEqual(2, e1.Current);
+        /// var rng = Enumerable.Range(0, 10).Publish();
+        /// var e1 = rng.GetEnumerator();    // e1 has a view on the source starting from element 0
+        /// Assert.IsTrue(e1.MoveNext());
+        /// Assert.AreEqual(0, e1.Current);
+        /// Assert.IsTrue(e1.MoveNext());
+        /// Assert.AreEqual(1, e1.Current);
+        /// var e2 = rng.GetEnumerator();
+        /// Assert.IsTrue(e2.MoveNext());    // e2 has a view on the source starting from element 2
+        /// Assert.AreEqual(2, e2.Current);
+        /// Assert.IsTrue(e1.MoveNext());    // e1 continues to enumerate over its view
+        /// Assert.AreEqual(2, e1.Current);
         /// </example>
         public static IBuffer<TSource> Publish<TSource>(this IEnumerable<TSource> source)
         {
@@ -41,8 +41,8 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Publishes the source sequence within a selector function where each enumerator can obtain a view over a tail of the
-        ///     source sequence.
+        /// Publishes the source sequence within a selector function where each enumerator can obtain a view over a tail of the
+        /// source sequence.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Repeat.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Generates a sequence by repeating the given value infinitely.
+        /// Generates a sequence by repeating the given value infinitely.
         /// </summary>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>
         /// <param name="value">Value to repreat in the resulting sequence.</param>
@@ -21,7 +21,7 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Generates a sequence that contains one repeated value.
+        /// Generates a sequence that contains one repeated value.
         /// </summary>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>
         /// <param name="element">The value to be repeated.</param>
@@ -33,7 +33,7 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Repeats and concatenates the source sequence infinitely.
+        /// Repeats and concatenates the source sequence infinitely.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
@@ -47,7 +47,7 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Repeats and concatenates the source sequence the given number of times.
+        /// Repeats and concatenates the source sequence the given number of times.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Retry.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Creates a sequence that retries enumerating the source sequence as long as an error occurs.
+        /// Creates a sequence that retries enumerating the source sequence as long as an error occurs.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
@@ -23,8 +23,8 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Creates a sequence that retries enumerating the source sequence as long as an error occurs, with the specified
-        ///     maximum number of retries.
+        /// Creates a sequence that retries enumerating the source sequence as long as an error occurs, with the specified
+        /// maximum number of retries.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Return.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Returns a sequence with a single element.
+        /// Returns a sequence with a single element.
         /// </summary>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>
         /// <param name="value">Single element of the resulting sequence.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Scan.cs

@@ -9,15 +9,15 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Generates a sequence of accumulated values by scanning the source sequence and applying an accumulator function.
+        /// Generates a sequence of accumulated values by scanning the source sequence and applying an accumulator function.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <typeparam name="TAccumulate">Accumulation type.</typeparam>
         /// <param name="source">Source sequence.</param>
         /// <param name="seed">Accumulator seed value.</param>
         /// <param name="accumulator">
-        ///     Accumulation function to apply to the current accumulation value and each element of the
-        ///     sequence.
+        /// Accumulation function to apply to the current accumulation value and each element of the
+        /// sequence.
         /// </param>
         /// <returns>Sequence with all intermediate accumulation values resulting from scanning the sequence.</returns>
         public static IEnumerable<TAccumulate> Scan<TSource, TAccumulate>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator)
@@ -31,13 +31,13 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Generates a sequence of accumulated values by scanning the source sequence and applying an accumulator function.
+        /// Generates a sequence of accumulated values by scanning the source sequence and applying an accumulator function.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
         /// <param name="accumulator">
-        ///     Accumulation function to apply to the current accumulation value and each element of the
-        ///     sequence.
+        /// Accumulation function to apply to the current accumulation value and each element of the
+        /// sequence.
         /// </param>
         /// <returns>Sequence with all intermediate accumulation values resulting from scanning the sequence.</returns>
         public static IEnumerable<TSource> Scan<TSource>(this IEnumerable<TSource> source, Func<TSource, TSource, TSource> accumulator)

Ix.NET/Source/System.Interactive/System/Linq/Operators/SelectMany.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Projects each element of a sequence to an given sequence and flattens the resulting sequences into one sequence.
+        /// Projects each element of a sequence to an given sequence and flattens the resulting sequences into one sequence.
         /// </summary>
         /// <typeparam name="TSource">First source sequence element type.</typeparam>
         /// <typeparam name="TOther">Second source sequence element type.</typeparam>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Share.cs

@@ -10,24 +10,24 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Creates a buffer with a shared view over the source sequence, causing each enumerator to fetch the next element
-        ///     from the source sequence.
+        /// Creates a buffer with a shared view over the source sequence, causing each enumerator to fetch the next element
+        /// from the source sequence.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
         /// <returns>Buffer enabling each enumerator to retrieve elements from the shared source sequence.</returns>
         /// <example>
-        ///     var rng = Enumerable.Range(0, 10).Share();
-        ///     var e1 = rng.GetEnumerator();    // Both e1 and e2 will consume elements from
-        ///     var e2 = rng.GetEnumerator();    // the source sequence.
-        ///     Assert.IsTrue(e1.MoveNext());
-        ///     Assert.AreEqual(0, e1.Current);
-        ///     Assert.IsTrue(e1.MoveNext());
-        ///     Assert.AreEqual(1, e1.Current);
-        ///     Assert.IsTrue(e2.MoveNext());    // e2 "steals" element 2
-        ///     Assert.AreEqual(2, e2.Current);
-        ///     Assert.IsTrue(e1.MoveNext());    // e1 can't see element 2
-        ///     Assert.AreEqual(3, e1.Current);
+        /// var rng = Enumerable.Range(0, 10).Share();
+        /// var e1 = rng.GetEnumerator();    // Both e1 and e2 will consume elements from
+        /// var e2 = rng.GetEnumerator();    // the source sequence.
+        /// Assert.IsTrue(e1.MoveNext());
+        /// Assert.AreEqual(0, e1.Current);
+        /// Assert.IsTrue(e1.MoveNext());
+        /// Assert.AreEqual(1, e1.Current);
+        /// Assert.IsTrue(e2.MoveNext());    // e2 "steals" element 2
+        /// Assert.AreEqual(2, e2.Current);
+        /// Assert.IsTrue(e1.MoveNext());    // e1 can't see element 2
+        /// Assert.AreEqual(3, e1.Current);
         /// </example>
         public static IBuffer<TSource> Share<TSource>(this IEnumerable<TSource> source)
         {
@@ -38,8 +38,8 @@ namespace System.Linq
         }
 
         /// <summary>
-        ///     Shares the source sequence within a selector function where each enumerator can fetch the next element from the
-        ///     source sequence.
+        /// Shares the source sequence within a selector function where each enumerator can fetch the next element from the
+        /// source sequence.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>

Ix.NET/Source/System.Interactive/System/Linq/Operators/SkipLast.cs

@@ -9,13 +9,13 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Bypasses a specified number of contiguous elements from the end of the sequence and returns the remaining elements.
+        /// Bypasses a specified number of contiguous elements from the end of the sequence and returns the remaining elements.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>
         /// <param name="count">
-        ///     The number of elements to skip from the end of the sequence before returning the remaining
-        ///     elements.
+        /// The number of elements to skip from the end of the sequence before returning the remaining
+        /// elements.
         /// </param>
         /// <returns>Sequence bypassing the specified number of elements counting from the end of the source sequence.</returns>
         public static IEnumerable<TSource> SkipLast<TSource>(this IEnumerable<TSource> source, int count)

Ix.NET/Source/System.Interactive/System/Linq/Operators/StartsWith.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Returns the source sequence prefixed with the specified value.
+        /// Returns the source sequence prefixed with the specified value.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/TakeLast.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Returns a specified number of contiguous elements from the end of the sequence.
+        /// Returns a specified number of contiguous elements from the end of the sequence.
         /// </summary>
         /// <typeparam name="TSource">Source sequence element type.</typeparam>
         /// <param name="source">Source sequence.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Throw.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Returns a sequence that throws an exception upon enumeration.
+        /// Returns a sequence that throws an exception upon enumeration.
         /// </summary>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>
         /// <param name="exception">Exception to throw upon enumerating the resulting sequence.</param>

Ix.NET/Source/System.Interactive/System/Linq/Operators/Using.cs

@@ -9,8 +9,8 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Generates a sequence that's dependent on a resource object whose lifetime is determined by the sequence usage
-        ///     duration.
+        /// Generates a sequence that's dependent on a resource object whose lifetime is determined by the sequence usage
+        /// duration.
         /// </summary>
         /// <typeparam name="TSource">Source element type.</typeparam>
         /// <typeparam name="TResource">Resource type.</typeparam>

Ix.NET/Source/System.Interactive/System/Linq/Operators/While.cs

@@ -9,7 +9,7 @@ namespace System.Linq
     public static partial class EnumerableEx
     {
         /// <summary>
-        ///     Generates an enumerable sequence by repeating a source sequence as long as the given loop condition holds.
+        /// Generates an enumerable sequence by repeating a source sequence as long as the given loop condition holds.
         /// </summary>
         /// <typeparam name="TResult">Result sequence element type.</typeparam>
         /// <param name="condition">Loop condition.</param>