From 1f0b2a1f3540dfa8327057ed2ca104632b2c21cf Mon Sep 17 00:00:00 2001
From: Daniel Weber <dw@exram.de>
Date: Wed, 4 Jul 2018 09:53:44 +0200
Subject: [PATCH] Private setter for auto properties that are only assigned in
 the constructor can be omitted.

---
 .../src/System.Reactive/Joins/JoinObserver.cs |   2 +-
 .../src/System.Reactive/Joins/Pattern.cs      | 274 +++++++++---------
 .../Source/src/System.Reactive/Joins/Plan.cs  |  66 ++---
 .../System.Reactive/Joins/QueryablePattern.cs |   2 +-
 .../System.Reactive/Joins/QueryablePlan.cs    |   4 +-
 5 files changed, 174 insertions(+), 174 deletions(-)

diff --git a/Rx.NET/Source/src/System.Reactive/Joins/JoinObserver.cs b/Rx.NET/Source/src/System.Reactive/Joins/JoinObserver.cs
index aca5aaf18a..cc81ffcf3f 100644
--- a/Rx.NET/Source/src/System.Reactive/Joins/JoinObserver.cs
+++ b/Rx.NET/Source/src/System.Reactive/Joins/JoinObserver.cs
@@ -20,7 +20,7 @@ internal sealed class JoinObserver<T> : ObserverBase<Notification<T>>, IJoinObse
         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;
 
diff --git a/Rx.NET/Source/src/System.Reactive/Joins/Pattern.cs b/Rx.NET/Source/src/System.Reactive/Joins/Pattern.cs
index 4b42796371..bdc1435350 100644
--- a/Rx.NET/Source/src/System.Reactive/Joins/Pattern.cs
+++ b/Rx.NET/Source/src/System.Reactive/Joins/Pattern.cs
@@ -29,7 +29,7 @@ internal Pattern(IObservable<TSource1> first)
             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 @@ internal Pattern(IObservable<TSource1> first, IObservable<TSource2> second)
             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 @@ internal Pattern(IObservable<TSource1> first, IObservable<TSource2> second, IObs
             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 @@ internal Pattern(IObservable<TSource1> first, IObservable<TSource2> second, IObs
             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 @@ internal Pattern(IObservable<TSource1> first, IObservable<TSource2> second, IObs
             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 @@ internal Pattern(IObservable<TSource1> first, IObservable<TSource2> second, IObs
             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 @@ internal Pattern(IObservable<TSource1> first, IObservable<TSource2> second, IObs
             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 @@ internal Pattern(IObservable<TSource1> first, IObservable<TSource2> second, IObs
             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 @@ internal Pattern(IObservable<TSource1> first, IObservable<TSource2> second, IObs
             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 @@ internal Pattern(IObservable<TSource1> first, IObservable<TSource2> second, IObs
             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 @@ internal Pattern(IObservable<TSource1> first, IObservable<TSource2> second, IObs
             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 @@ internal Pattern(IObservable<TSource1> first, IObservable<TSource2> second, IObs
             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 @@ internal Pattern(IObservable<TSource1> first, IObservable<TSource2> second, IObs
             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 @@ internal Pattern(IObservable<TSource1> first, IObservable<TSource2> second, IObs
             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 @@ internal Pattern(IObservable<TSource1> first, IObservable<TSource2> second, IObs
             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 @@ internal Pattern(IObservable<TSource1> first, IObservable<TSource2> second, IObs
             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 @@ public Plan<TResult> Then<TResult>(Func<TSource1, TSource2, TSource3, TSource4,
     }
 
     #endregion
-}
\ No newline at end of file
+}
diff --git a/Rx.NET/Source/src/System.Reactive/Joins/Plan.cs b/Rx.NET/Source/src/System.Reactive/Joins/Plan.cs
index 824c6ecaf4..ccbf32079f 100644
--- a/Rx.NET/Source/src/System.Reactive/Joins/Plan.cs
+++ b/Rx.NET/Source/src/System.Reactive/Joins/Plan.cs
@@ -38,9 +38,9 @@ internal static JoinObserver<TSource> CreateObserver<TSource>(
 
     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 @@ internal override ActivePlan Activate(Dictionary<object, IJoinObserver> external
 
     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 @@ internal override ActivePlan Activate(Dictionary<object, IJoinObserver> external
 
     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 @@ internal override ActivePlan Activate(Dictionary<object, IJoinObserver> external
 
     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 @@ internal override ActivePlan Activate(Dictionary<object, IJoinObserver> external
 
     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 @@ internal override ActivePlan Activate(Dictionary<object, IJoinObserver> external
 
     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 @@ internal override ActivePlan Activate(Dictionary<object, IJoinObserver> external
 
     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 @@ internal override ActivePlan Activate(Dictionary<object, IJoinObserver> external
 
     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 @@ internal override ActivePlan Activate(Dictionary<object, IJoinObserver> external
 
     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 @@ internal override ActivePlan Activate(Dictionary<object, IJoinObserver> external
 
     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 @@ internal override ActivePlan Activate(Dictionary<object, IJoinObserver> external
 
     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 @@ internal override ActivePlan Activate(Dictionary<object, IJoinObserver> external
 
     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 @@ internal override ActivePlan Activate(Dictionary<object, IJoinObserver> external
 
     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 @@ internal override ActivePlan Activate(Dictionary<object, IJoinObserver> external
 
     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 @@ internal override ActivePlan Activate(Dictionary<object, IJoinObserver> external
 
     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 @@ internal override ActivePlan Activate(Dictionary<object, IJoinObserver> external
     }
     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 @@ internal override ActivePlan Activate(Dictionary<object, IJoinObserver> external
             return activePlan;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/Rx.NET/Source/src/System.Reactive/Joins/QueryablePattern.cs b/Rx.NET/Source/src/System.Reactive/Joins/QueryablePattern.cs
index 261bf080e6..5dd4067f5e 100644
--- a/Rx.NET/Source/src/System.Reactive/Joins/QueryablePattern.cs
+++ b/Rx.NET/Source/src/System.Reactive/Joins/QueryablePattern.cs
@@ -26,7 +26,7 @@ protected QueryablePattern(Expression expression)
         /// <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. */
diff --git a/Rx.NET/Source/src/System.Reactive/Joins/QueryablePlan.cs b/Rx.NET/Source/src/System.Reactive/Joins/QueryablePlan.cs
index 6ff55bf711..b4321126a3 100644
--- a/Rx.NET/Source/src/System.Reactive/Joins/QueryablePlan.cs
+++ b/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 @@ internal QueryablePlan(Expression expression)
         /// <summary>
         /// Gets the expression tree representing the join pattern execution plan.
         /// </summary>
-        public Expression Expression { get; private set; }
+        public Expression Expression { get; }
     }
 }