Merge pull request #755 from danielcweber/OmitPrivateSetter

Private setter for auto properties that are only assigned in the constructor can be omitted.

Rx.NET/Source/src/System.Reactive/Joins/JoinObserver.cs

@@ -20,7 +20,7 @@ namespace System.Reactive.Joins
         private readonly IObservable<T> _source;
         private readonly Action<Exception> _onError;
         private readonly List<ActivePlan> _activePlans;
-        public Queue<Notification<T>> Queue { get; private set; }
+        public Queue<Notification<T>> Queue { get; }
         private IDisposable _subscription;
         private bool _isDisposed;
 

Rx.NET/Source/src/System.Reactive/Joins/Pattern.cs

@@ -29,7 +29,7 @@ namespace System.Reactive.Joins
             First = first;
         }
 
-        internal IObservable<TSource1> First { get; private set; }
+        internal IObservable<TSource1> First { get; }
 
         /// <summary>
         /// Matches when all observable sequences have an available element and projects the elements by invoking the selector function.
@@ -63,8 +63,8 @@ namespace System.Reactive.Joins
             Second = second;
         }
 
-        internal IObservable<TSource1> First { get; private set; }
-        internal IObservable<TSource2> Second { get; private set; }
+        internal IObservable<TSource1> First { get; }
+        internal IObservable<TSource2> Second { get; }
 
         /// <summary>
         /// Creates a pattern that matches when all three observable sequences have an available element.
@@ -117,9 +117,9 @@ namespace System.Reactive.Joins
             Third = third;
         }
 
-        internal IObservable<TSource1> First { get; private set; }
-        internal IObservable<TSource2> Second { get; private set; }
-        internal IObservable<TSource3> Third { get; private set; }
+        internal IObservable<TSource1> First { get; }
+        internal IObservable<TSource2> Second { get; }
+        internal IObservable<TSource3> Third { get; }
 
         /// <summary>
         /// Creates a pattern that matches when all four observable sequences have an available element.
@@ -174,10 +174,10 @@ namespace System.Reactive.Joins
             Fourth = fourth;
         }
 
-        internal IObservable<TSource1> First { get; private set; }
-        internal IObservable<TSource2> Second { get; private set; }
-        internal IObservable<TSource3> Third { get; private set; }
-        internal IObservable<TSource4> Fourth { get; private set; }
+        internal IObservable<TSource1> First { get; }
+        internal IObservable<TSource2> Second { get; }
+        internal IObservable<TSource3> Third { get; }
+        internal IObservable<TSource4> Fourth { get; }
 
         /// <summary>
         /// Creates a pattern that matches when all five observable sequences have an available element.
@@ -234,11 +234,11 @@ namespace System.Reactive.Joins
             Fifth = fifth;
         }
 
-        internal IObservable<TSource1> First { get; private set; }
-        internal IObservable<TSource2> Second { get; private set; }
-        internal IObservable<TSource3> Third { get; private set; }
-        internal IObservable<TSource4> Fourth { get; private set; }
-        internal IObservable<TSource5> Fifth { get; private set; }
+        internal IObservable<TSource1> First { get; }
+        internal IObservable<TSource2> Second { get; }
+        internal IObservable<TSource3> Third { get; }
+        internal IObservable<TSource4> Fourth { get; }
+        internal IObservable<TSource5> Fifth { get; }
 
         /// <summary>
         /// Creates a pattern that matches when all six observable sequences have an available element.
@@ -297,12 +297,12 @@ namespace System.Reactive.Joins
             Sixth = sixth;
         }
 
-        internal IObservable<TSource1> First { get; private set; }
-        internal IObservable<TSource2> Second { get; private set; }
-        internal IObservable<TSource3> Third { get; private set; }
-        internal IObservable<TSource4> Fourth { get; private set; }
-        internal IObservable<TSource5> Fifth { get; private set; }
-        internal IObservable<TSource6> Sixth { get; private set; }
+        internal IObservable<TSource1> First { get; }
+        internal IObservable<TSource2> Second { get; }
+        internal IObservable<TSource3> Third { get; }
+        internal IObservable<TSource4> Fourth { get; }
+        internal IObservable<TSource5> Fifth { get; }
+        internal IObservable<TSource6> Sixth { get; }
 
         /// <summary>
         /// Creates a pattern that matches when all seven observable sequences have an available element.
@@ -363,13 +363,13 @@ namespace System.Reactive.Joins
             Seventh = seventh;
         }
 
-        internal IObservable<TSource1> First { get; private set; }
-        internal IObservable<TSource2> Second { get; private set; }
-        internal IObservable<TSource3> Third { get; private set; }
-        internal IObservable<TSource4> Fourth { get; private set; }
-        internal IObservable<TSource5> Fifth { get; private set; }
-        internal IObservable<TSource6> Sixth { get; private set; }
-        internal IObservable<TSource7> Seventh { get; private set; }
+        internal IObservable<TSource1> First { get; }
+        internal IObservable<TSource2> Second { get; }
+        internal IObservable<TSource3> Third { get; }
+        internal IObservable<TSource4> Fourth { get; }
+        internal IObservable<TSource5> Fifth { get; }
+        internal IObservable<TSource6> Sixth { get; }
+        internal IObservable<TSource7> Seventh { get; }
 
         /// <summary>
         /// Creates a pattern that matches when all eight observable sequences have an available element.
@@ -432,14 +432,14 @@ namespace System.Reactive.Joins
             Eighth = eighth;
         }
 
-        internal IObservable<TSource1> First { get; private set; }
-        internal IObservable<TSource2> Second { get; private set; }
-        internal IObservable<TSource3> Third { get; private set; }
-        internal IObservable<TSource4> Fourth { get; private set; }
-        internal IObservable<TSource5> Fifth { get; private set; }
-        internal IObservable<TSource6> Sixth { get; private set; }
-        internal IObservable<TSource7> Seventh { get; private set; }
-        internal IObservable<TSource8> Eighth { get; private set; }
+        internal IObservable<TSource1> First { get; }
+        internal IObservable<TSource2> Second { get; }
+        internal IObservable<TSource3> Third { get; }
+        internal IObservable<TSource4> Fourth { get; }
+        internal IObservable<TSource5> Fifth { get; }
+        internal IObservable<TSource6> Sixth { get; }
+        internal IObservable<TSource7> Seventh { get; }
+        internal IObservable<TSource8> Eighth { get; }
 
         /// <summary>
         /// Creates a pattern that matches when all nine observable sequences have an available element.
@@ -504,15 +504,15 @@ namespace System.Reactive.Joins
             Ninth = ninth;
         }
 
-        internal IObservable<TSource1> First { get; private set; }
-        internal IObservable<TSource2> Second { get; private set; }
-        internal IObservable<TSource3> Third { get; private set; }
-        internal IObservable<TSource4> Fourth { get; private set; }
-        internal IObservable<TSource5> Fifth { get; private set; }
-        internal IObservable<TSource6> Sixth { get; private set; }
-        internal IObservable<TSource7> Seventh { get; private set; }
-        internal IObservable<TSource8> Eighth { get; private set; }
-        internal IObservable<TSource9> Ninth { get; private set; }
+        internal IObservable<TSource1> First { get; }
+        internal IObservable<TSource2> Second { get; }
+        internal IObservable<TSource3> Third { get; }
+        internal IObservable<TSource4> Fourth { get; }
+        internal IObservable<TSource5> Fifth { get; }
+        internal IObservable<TSource6> Sixth { get; }
+        internal IObservable<TSource7> Seventh { get; }
+        internal IObservable<TSource8> Eighth { get; }
+        internal IObservable<TSource9> Ninth { get; }
 
         /// <summary>
         /// Creates a pattern that matches when all ten observable sequences have an available element.
@@ -579,16 +579,16 @@ namespace System.Reactive.Joins
             Tenth = tenth;
         }
 
-        internal IObservable<TSource1> First { get; private set; }
-        internal IObservable<TSource2> Second { get; private set; }
-        internal IObservable<TSource3> Third { get; private set; }
-        internal IObservable<TSource4> Fourth { get; private set; }
-        internal IObservable<TSource5> Fifth { get; private set; }
-        internal IObservable<TSource6> Sixth { get; private set; }
-        internal IObservable<TSource7> Seventh { get; private set; }
-        internal IObservable<TSource8> Eighth { get; private set; }
-        internal IObservable<TSource9> Ninth { get; private set; }
-        internal IObservable<TSource10> Tenth { get; private set; }
+        internal IObservable<TSource1> First { get; }
+        internal IObservable<TSource2> Second { get; }
+        internal IObservable<TSource3> Third { get; }
+        internal IObservable<TSource4> Fourth { get; }
+        internal IObservable<TSource5> Fifth { get; }
+        internal IObservable<TSource6> Sixth { get; }
+        internal IObservable<TSource7> Seventh { get; }
+        internal IObservable<TSource8> Eighth { get; }
+        internal IObservable<TSource9> Ninth { get; }
+        internal IObservable<TSource10> Tenth { get; }
 
         /// <summary>
         /// Creates a pattern that matches when all eleven observable sequences have an available element.
@@ -657,17 +657,17 @@ namespace System.Reactive.Joins
             Eleventh = eleventh;
         }
 
-        internal IObservable<TSource1> First { get; private set; }
-        internal IObservable<TSource2> Second { get; private set; }
-        internal IObservable<TSource3> Third { get; private set; }
-        internal IObservable<TSource4> Fourth { get; private set; }
-        internal IObservable<TSource5> Fifth { get; private set; }
-        internal IObservable<TSource6> Sixth { get; private set; }
-        internal IObservable<TSource7> Seventh { get; private set; }
-        internal IObservable<TSource8> Eighth { get; private set; }
-        internal IObservable<TSource9> Ninth { get; private set; }
-        internal IObservable<TSource10> Tenth { get; private set; }
-        internal IObservable<TSource11> Eleventh { get; private set; }
+        internal IObservable<TSource1> First { get; }
+        internal IObservable<TSource2> Second { get; }
+        internal IObservable<TSource3> Third { get; }
+        internal IObservable<TSource4> Fourth { get; }
+        internal IObservable<TSource5> Fifth { get; }
+        internal IObservable<TSource6> Sixth { get; }
+        internal IObservable<TSource7> Seventh { get; }
+        internal IObservable<TSource8> Eighth { get; }
+        internal IObservable<TSource9> Ninth { get; }
+        internal IObservable<TSource10> Tenth { get; }
+        internal IObservable<TSource11> Eleventh { get; }
 
         /// <summary>
         /// Creates a pattern that matches when all twelve observable sequences have an available element.
@@ -738,18 +738,18 @@ namespace System.Reactive.Joins
             Twelfth = twelfth;
         }
 
-        internal IObservable<TSource1> First { get; private set; }
-        internal IObservable<TSource2> Second { get; private set; }
-        internal IObservable<TSource3> Third { get; private set; }
-        internal IObservable<TSource4> Fourth { get; private set; }
-        internal IObservable<TSource5> Fifth { get; private set; }
-        internal IObservable<TSource6> Sixth { get; private set; }
-        internal IObservable<TSource7> Seventh { get; private set; }
-        internal IObservable<TSource8> Eighth { get; private set; }
-        internal IObservable<TSource9> Ninth { get; private set; }
-        internal IObservable<TSource10> Tenth { get; private set; }
-        internal IObservable<TSource11> Eleventh { get; private set; }
-        internal IObservable<TSource12> Twelfth { get; private set; }
+        internal IObservable<TSource1> First { get; }
+        internal IObservable<TSource2> Second { get; }
+        internal IObservable<TSource3> Third { get; }
+        internal IObservable<TSource4> Fourth { get; }
+        internal IObservable<TSource5> Fifth { get; }
+        internal IObservable<TSource6> Sixth { get; }
+        internal IObservable<TSource7> Seventh { get; }
+        internal IObservable<TSource8> Eighth { get; }
+        internal IObservable<TSource9> Ninth { get; }
+        internal IObservable<TSource10> Tenth { get; }
+        internal IObservable<TSource11> Eleventh { get; }
+        internal IObservable<TSource12> Twelfth { get; }
 
         /// <summary>
         /// Creates a pattern that matches when all thirteen observable sequences have an available element.
@@ -822,19 +822,19 @@ namespace System.Reactive.Joins
             Thirteenth = thirteenth;
         }
 
-        internal IObservable<TSource1> First { get; private set; }
-        internal IObservable<TSource2> Second { get; private set; }
-        internal IObservable<TSource3> Third { get; private set; }
-        internal IObservable<TSource4> Fourth { get; private set; }
-        internal IObservable<TSource5> Fifth { get; private set; }
-        internal IObservable<TSource6> Sixth { get; private set; }
-        internal IObservable<TSource7> Seventh { get; private set; }
-        internal IObservable<TSource8> Eighth { get; private set; }
-        internal IObservable<TSource9> Ninth { get; private set; }
-        internal IObservable<TSource10> Tenth { get; private set; }
-        internal IObservable<TSource11> Eleventh { get; private set; }
-        internal IObservable<TSource12> Twelfth { get; private set; }
-        internal IObservable<TSource13> Thirteenth { get; private set; }
+        internal IObservable<TSource1> First { get; }
+        internal IObservable<TSource2> Second { get; }
+        internal IObservable<TSource3> Third { get; }
+        internal IObservable<TSource4> Fourth { get; }
+        internal IObservable<TSource5> Fifth { get; }
+        internal IObservable<TSource6> Sixth { get; }
+        internal IObservable<TSource7> Seventh { get; }
+        internal IObservable<TSource8> Eighth { get; }
+        internal IObservable<TSource9> Ninth { get; }
+        internal IObservable<TSource10> Tenth { get; }
+        internal IObservable<TSource11> Eleventh { get; }
+        internal IObservable<TSource12> Twelfth { get; }
+        internal IObservable<TSource13> Thirteenth { get; }
 
         /// <summary>
         /// Creates a pattern that matches when all fourteen observable sequences have an available element.
@@ -909,20 +909,20 @@ namespace System.Reactive.Joins
             Fourteenth = fourteenth;
         }
 
-        internal IObservable<TSource1> First { get; private set; }
-        internal IObservable<TSource2> Second { get; private set; }
-        internal IObservable<TSource3> Third { get; private set; }
-        internal IObservable<TSource4> Fourth { get; private set; }
-        internal IObservable<TSource5> Fifth { get; private set; }
-        internal IObservable<TSource6> Sixth { get; private set; }
-        internal IObservable<TSource7> Seventh { get; private set; }
-        internal IObservable<TSource8> Eighth { get; private set; }
-        internal IObservable<TSource9> Ninth { get; private set; }
-        internal IObservable<TSource10> Tenth { get; private set; }
-        internal IObservable<TSource11> Eleventh { get; private set; }
-        internal IObservable<TSource12> Twelfth { get; private set; }
-        internal IObservable<TSource13> Thirteenth { get; private set; }
-        internal IObservable<TSource14> Fourteenth { get; private set; }
+        internal IObservable<TSource1> First { get; }
+        internal IObservable<TSource2> Second { get; }
+        internal IObservable<TSource3> Third { get; }
+        internal IObservable<TSource4> Fourth { get; }
+        internal IObservable<TSource5> Fifth { get; }
+        internal IObservable<TSource6> Sixth { get; }
+        internal IObservable<TSource7> Seventh { get; }
+        internal IObservable<TSource8> Eighth { get; }
+        internal IObservable<TSource9> Ninth { get; }
+        internal IObservable<TSource10> Tenth { get; }
+        internal IObservable<TSource11> Eleventh { get; }
+        internal IObservable<TSource12> Twelfth { get; }
+        internal IObservable<TSource13> Thirteenth { get; }
+        internal IObservable<TSource14> Fourteenth { get; }
 
         /// <summary>
         /// Creates a pattern that matches when all fifteen observable sequences have an available element.
@@ -999,21 +999,21 @@ namespace System.Reactive.Joins
             Fifteenth = fifteenth;
         }
 
-        internal IObservable<TSource1> First { get; private set; }
-        internal IObservable<TSource2> Second { get; private set; }
-        internal IObservable<TSource3> Third { get; private set; }
-        internal IObservable<TSource4> Fourth { get; private set; }
-        internal IObservable<TSource5> Fifth { get; private set; }
-        internal IObservable<TSource6> Sixth { get; private set; }
-        internal IObservable<TSource7> Seventh { get; private set; }
-        internal IObservable<TSource8> Eighth { get; private set; }
-        internal IObservable<TSource9> Ninth { get; private set; }
-        internal IObservable<TSource10> Tenth { get; private set; }
-        internal IObservable<TSource11> Eleventh { get; private set; }
-        internal IObservable<TSource12> Twelfth { get; private set; }
-        internal IObservable<TSource13> Thirteenth { get; private set; }
-        internal IObservable<TSource14> Fourteenth { get; private set; }
-        internal IObservable<TSource15> Fifteenth { get; private set; }
+        internal IObservable<TSource1> First { get; }
+        internal IObservable<TSource2> Second { get; }
+        internal IObservable<TSource3> Third { get; }
+        internal IObservable<TSource4> Fourth { get; }
+        internal IObservable<TSource5> Fifth { get; }
+        internal IObservable<TSource6> Sixth { get; }
+        internal IObservable<TSource7> Seventh { get; }
+        internal IObservable<TSource8> Eighth { get; }
+        internal IObservable<TSource9> Ninth { get; }
+        internal IObservable<TSource10> Tenth { get; }
+        internal IObservable<TSource11> Eleventh { get; }
+        internal IObservable<TSource12> Twelfth { get; }
+        internal IObservable<TSource13> Thirteenth { get; }
+        internal IObservable<TSource14> Fourteenth { get; }
+        internal IObservable<TSource15> Fifteenth { get; }
 
         /// <summary>
         /// Creates a pattern that matches when all sixteen observable sequences have an available element.
@@ -1092,22 +1092,22 @@ namespace System.Reactive.Joins
             Sixteenth = sixteenth;
         }
 
-        internal IObservable<TSource1> First { get; private set; }
-        internal IObservable<TSource2> Second { get; private set; }
-        internal IObservable<TSource3> Third { get; private set; }
-        internal IObservable<TSource4> Fourth { get; private set; }
-        internal IObservable<TSource5> Fifth { get; private set; }
-        internal IObservable<TSource6> Sixth { get; private set; }
-        internal IObservable<TSource7> Seventh { get; private set; }
-        internal IObservable<TSource8> Eighth { get; private set; }
-        internal IObservable<TSource9> Ninth { get; private set; }
-        internal IObservable<TSource10> Tenth { get; private set; }
-        internal IObservable<TSource11> Eleventh { get; private set; }
-        internal IObservable<TSource12> Twelfth { get; private set; }
-        internal IObservable<TSource13> Thirteenth { get; private set; }
-        internal IObservable<TSource14> Fourteenth { get; private set; }
-        internal IObservable<TSource15> Fifteenth { get; private set; }
-        internal IObservable<TSource16> Sixteenth { get; private set; }
+        internal IObservable<TSource1> First { get; }
+        internal IObservable<TSource2> Second { get; }
+        internal IObservable<TSource3> Third { get; }
+        internal IObservable<TSource4> Fourth { get; }
+        internal IObservable<TSource5> Fifth { get; }
+        internal IObservable<TSource6> Sixth { get; }
+        internal IObservable<TSource7> Seventh { get; }
+        internal IObservable<TSource8> Eighth { get; }
+        internal IObservable<TSource9> Ninth { get; }
+        internal IObservable<TSource10> Tenth { get; }
+        internal IObservable<TSource11> Eleventh { get; }
+        internal IObservable<TSource12> Twelfth { get; }
+        internal IObservable<TSource13> Thirteenth { get; }
+        internal IObservable<TSource14> Fourteenth { get; }
+        internal IObservable<TSource15> Fifteenth { get; }
+        internal IObservable<TSource16> Sixteenth { get; }
 
         /// <summary>
         /// Matches when all observable sequences have an available element and projects the elements by invoking the selector function.
@@ -1129,4 +1129,4 @@ namespace System.Reactive.Joins
     }
 
     #endregion
-}
+}

Rx.NET/Source/src/System.Reactive/Joins/Plan.cs

@@ -38,9 +38,9 @@ namespace System.Reactive.Joins
 
     internal class Plan<T1, TResult> : Plan<TResult>
     {
-        internal Pattern<T1> Expression { get; private set; }
+        internal Pattern<T1> Expression { get; }
 
-        internal Func<T1, TResult> Selector { get; private set; }
+        internal Func<T1, TResult> Selector { get; }
 
         internal Plan(Pattern<T1> expression, Func<T1, TResult> selector)
         {
@@ -83,9 +83,9 @@ namespace System.Reactive.Joins
 
     internal class Plan<T1, T2, TResult> : Plan<TResult>
     {
-        internal Pattern<T1, T2> Expression { get; private set; }
+        internal Pattern<T1, T2> Expression { get; }
 
-        internal Func<T1, T2, TResult> Selector { get; private set; }
+        internal Func<T1, T2, TResult> Selector { get; }
 
         internal Plan(Pattern<T1, T2> expression, Func<T1, T2, TResult> selector)
         {
@@ -131,9 +131,9 @@ namespace System.Reactive.Joins
 
     internal class Plan<T1, T2, T3, TResult> : Plan<TResult>
     {
-        internal Pattern<T1, T2, T3> Expression { get; private set; }
+        internal Pattern<T1, T2, T3> Expression { get; }
 
-        internal Func<T1, T2, T3, TResult> Selector { get; private set; }
+        internal Func<T1, T2, T3, TResult> Selector { get; }
 
         internal Plan(Pattern<T1, T2, T3> expression, Func<T1, T2, T3, TResult> selector)
         {
@@ -183,9 +183,9 @@ namespace System.Reactive.Joins
 
     internal class Plan<T1, T2, T3, T4, TResult> : Plan<TResult>
     {
-        internal Pattern<T1, T2, T3, T4> Expression { get; private set; }
+        internal Pattern<T1, T2, T3, T4> Expression { get; }
 
-        internal Func<T1, T2, T3, T4, TResult> Selector { get; private set; }
+        internal Func<T1, T2, T3, T4, TResult> Selector { get; }
 
         internal Plan(Pattern<T1, T2, T3, T4> expression,
                       Func<T1, T2, T3, T4, TResult> selector)
@@ -238,9 +238,9 @@ namespace System.Reactive.Joins
 
     internal class Plan<T1, T2, T3, T4, T5, TResult> : Plan<TResult>
     {
-        internal Pattern<T1, T2, T3, T4, T5> Expression { get; private set; }
+        internal Pattern<T1, T2, T3, T4, T5> Expression { get; }
 
-        internal Func<T1, T2, T3, T4, T5, TResult> Selector { get; private set; }
+        internal Func<T1, T2, T3, T4, T5, TResult> Selector { get; }
 
         internal Plan(Pattern<T1, T2, T3, T4, T5> expression,
                       Func<T1, T2, T3, T4, T5, TResult> selector)
@@ -296,9 +296,9 @@ namespace System.Reactive.Joins
 
     internal class Plan<T1, T2, T3, T4, T5, T6, TResult> : Plan<TResult>
     {
-        internal Pattern<T1, T2, T3, T4, T5, T6> Expression { get; private set; }
+        internal Pattern<T1, T2, T3, T4, T5, T6> Expression { get; }
 
-        internal Func<T1, T2, T3, T4, T5, T6, TResult> Selector { get; private set; }
+        internal Func<T1, T2, T3, T4, T5, T6, TResult> Selector { get; }
 
         internal Plan(Pattern<T1, T2, T3, T4, T5, T6> expression,
                       Func<T1, T2, T3, T4, T5, T6, TResult> selector)
@@ -358,9 +358,9 @@ namespace System.Reactive.Joins
 
     internal class Plan<T1, T2, T3, T4, T5, T6, T7, TResult> : Plan<TResult>
     {
-        internal Pattern<T1, T2, T3, T4, T5, T6, T7> Expression { get; private set; }
+        internal Pattern<T1, T2, T3, T4, T5, T6, T7> Expression { get; }
 
-        internal Func<T1, T2, T3, T4, T5, T6, T7, TResult> Selector { get; private set; }
+        internal Func<T1, T2, T3, T4, T5, T6, T7, TResult> Selector { get; }
 
         internal Plan(Pattern<T1, T2, T3, T4, T5, T6, T7> expression,
                       Func<T1, T2, T3, T4, T5, T6, T7, TResult> selector)
@@ -423,9 +423,9 @@ namespace System.Reactive.Joins
 
     internal class Plan<T1, T2, T3, T4, T5, T6, T7, T8, TResult> : Plan<TResult>
     {
-        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8> Expression { get; private set; }
+        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8> Expression { get; }
 
-        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> Selector { get; private set; }
+        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> Selector { get; }
 
         internal Plan(Pattern<T1, T2, T3, T4, T5, T6, T7, T8> expression,
                       Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> selector)
@@ -491,9 +491,9 @@ namespace System.Reactive.Joins
 
     internal class Plan<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> : Plan<TResult>
     {
-        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9> Expression { get; private set; }
+        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9> Expression { get; }
 
-        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> Selector { get; private set; }
+        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> Selector { get; }
 
         internal Plan(Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9> expression,
                       Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> selector)
@@ -562,9 +562,9 @@ namespace System.Reactive.Joins
 
     internal class Plan<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> : Plan<TResult>
     {
-        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Expression { get; private set; }
+        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Expression { get; }
 
-        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> Selector { get; private set; }
+        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> Selector { get; }
 
         internal Plan(Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> expression,
                       Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> selector)
@@ -636,9 +636,9 @@ namespace System.Reactive.Joins
 
     internal class Plan<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> : Plan<TResult>
     {
-        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Expression { get; private set; }
+        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Expression { get; }
 
-        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> Selector { get; private set; }
+        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> Selector { get; }
 
         internal Plan(Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> expression,
                       Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> selector)
@@ -714,9 +714,9 @@ namespace System.Reactive.Joins
 
     internal class Plan<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> : Plan<TResult>
     {
-        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Expression { get; private set; }
+        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Expression { get; }
 
-        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> Selector { get; private set; }
+        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> Selector { get; }
 
         internal Plan(Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> expression,
                       Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> selector)
@@ -797,9 +797,9 @@ namespace System.Reactive.Joins
 
     internal class Plan<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> : Plan<TResult>
     {
-        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Expression { get; private set; }
+        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Expression { get; }
 
-        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> Selector { get; private set; }
+        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> Selector { get; }
 
         internal Plan(Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> expression,
                       Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> selector)
@@ -883,9 +883,9 @@ namespace System.Reactive.Joins
 
     internal class Plan<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> : Plan<TResult>
     {
-        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Expression { get; private set; }
+        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Expression { get; }
 
-        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> Selector { get; private set; }
+        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> Selector { get; }
 
         internal Plan(Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> expression,
                       Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> selector)
@@ -975,9 +975,9 @@ namespace System.Reactive.Joins
 
     internal class Plan<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> : Plan<TResult>
     {
-        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Expression { get; private set; }
+        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Expression { get; }
 
-        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> Selector { get; private set; }
+        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> Selector { get; }
 
         internal Plan(Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> expression,
                       Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> selector)
@@ -1069,9 +1069,9 @@ namespace System.Reactive.Joins
     }
     internal class Plan<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> : Plan<TResult>
     {
-        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Expression { get; private set; }
+        internal Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Expression { get; }
 
-        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> Selector { get; private set; }
+        internal Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> Selector { get; }
 
         internal Plan(Pattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> expression,
                       Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> selector)
@@ -1165,4 +1165,4 @@ namespace System.Reactive.Joins
             return activePlan;
         }
     }
-}
+}

Rx.NET/Source/src/System.Reactive/Joins/QueryablePattern.cs

@@ -26,7 +26,7 @@ namespace System.Reactive.Joins
         /// <summary>
         /// Gets the expression tree representing the join pattern.
         /// </summary>
-        public Expression Expression { get; private set; }
+        public Expression Expression { get; }
     }
 
     /* The following code is generated by a tool checked in to $/.../Source/Tools/CodeGenerators. */

Rx.NET/Source/src/System.Reactive/Joins/QueryablePlan.cs

@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information. 
 
@@ -22,7 +22,7 @@ namespace System.Reactive.Joins
         /// <summary>
         /// Gets the expression tree representing the join pattern execution plan.
         /// </summary>
-        public Expression Expression { get; private set; }
+        public Expression Expression { get; }
     }
 }