Expose SocketsHttpHandler.MaxResponseDrainSize

Author: stephentoub

src/System.Net.Http/ref/System.Net.Http.cs

@@ -248,6 +248,7 @@ public SocketsHttpHandler() { }
         public System.TimeSpan Expect100ContinueTimeout { get; set; }
         public int MaxAutomaticRedirections { get { throw null; } set { } }
         public int MaxConnectionsPerServer { get { throw null; } set { } }
+        public int MaxResponseDrainSize { get { throw null; } set { } }
         public int MaxResponseHeadersLength { get { throw null; } set { } }
         public bool PreAuthenticate { get { throw null; } set { } }
         public System.TimeSpan PooledConnectionIdleTimeout { get { throw null; } set { } }

src/System.Net.Http/src/ILLinkTrim.xml

@@ -2,6 +2,5 @@
   <assembly fullname="System.Net.Http">
     <!-- Anonymous types are used with DiagnosticSource logging and subscribers reflect over those, calling their public getters. -->
     <type fullname="*f__AnonymousType*" />
-    <type fullname="System.Net.Http.SocketsHttpHandler" /> <!-- TODO #27329: Remove this once MaxResponseDrainSize is exposed -->
   </assembly>
 </linker>

src/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/SocketsHttpHandler.cs

@@ -152,7 +152,7 @@ public int MaxConnectionsPerServer
             }
         }
 
-        internal int MaxResponseDrainSize // TODO #27329: Expose publicly.
+        public int MaxResponseDrainSize
         {
             get => _settings._maxResponseDrainSize;
             set

src/System.Net.Http/tests/FunctionalTests/SocketsHttpHandlerTest.cs

@@ -77,33 +77,18 @@ public sealed class SocketsHttpHandler_HttpClientHandler_ResponseDrain_Test : Ht
     {
         protected override bool UseSocketsHttpHandler => true;
 
-        // Set MaxResponseDrainSize. TODO #27329: Avoid reflection once exposed publicly.
-        private int GetMaxResponseDrainSize(SocketsHttpHandler handler) =>
-            (int)typeof(SocketsHttpHandler).GetProperty("MaxResponseDrainSize", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(handler);
-        private void SetMaxResponseDrainSize(SocketsHttpHandler handler, int value)
-        {
-            try
-            {
-                typeof(SocketsHttpHandler).GetProperty("MaxResponseDrainSize", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(handler, value);
-            }
-            catch (TargetInvocationException tie)
-            {
-                throw tie.InnerException;
-            }
-        }
-
         [Fact]
         public void MaxResponseDrainSize_Roundtrips()
         {
             using (var handler = new SocketsHttpHandler())
             {
-                Assert.Equal(1024 * 1024, GetMaxResponseDrainSize(handler));
+                Assert.Equal(1024 * 1024, handler.MaxResponseDrainSize);
 
-                SetMaxResponseDrainSize(handler, 0);
-                Assert.Equal(0, GetMaxResponseDrainSize(handler));
+                handler.MaxResponseDrainSize = 0;
+                Assert.Equal(0, handler.MaxResponseDrainSize);
 
-                SetMaxResponseDrainSize(handler, int.MaxValue);
-                Assert.Equal(int.MaxValue, GetMaxResponseDrainSize(handler));
+                handler.MaxResponseDrainSize = int.MaxValue;
+                Assert.Equal(int.MaxValue, handler.MaxResponseDrainSize);
             }
         }
 
@@ -112,12 +97,12 @@ public void MaxResponseDrainSize_InvalidArgument_Throws()
         {
             using (var handler = new SocketsHttpHandler())
             {
-                Assert.Equal(1024 * 1024, GetMaxResponseDrainSize(handler));
+                Assert.Equal(1024 * 1024, handler.MaxResponseDrainSize);
 
-                AssertExtensions.Throws<ArgumentOutOfRangeException>("value", () => SetMaxResponseDrainSize(handler, -1));
-                AssertExtensions.Throws<ArgumentOutOfRangeException>("value", () => SetMaxResponseDrainSize(handler, int.MinValue));
+                AssertExtensions.Throws<ArgumentOutOfRangeException>("value", () => handler.MaxResponseDrainSize = -1);
+                AssertExtensions.Throws<ArgumentOutOfRangeException>("value", () => handler.MaxResponseDrainSize = int.MinValue);
 
-                Assert.Equal(1024 * 1024, GetMaxResponseDrainSize(handler));
+                Assert.Equal(1024 * 1024, handler.MaxResponseDrainSize);
             }
         }
 
@@ -127,10 +112,10 @@ public void MaxResponseDrainSize_SetAfterUse_Throws()
             using (var handler = new SocketsHttpHandler())
             using (var client = new HttpClient(handler))
             {
-                SetMaxResponseDrainSize(handler, 1);
+                handler.MaxResponseDrainSize = 1;
                 client.GetAsync("http://" + Guid.NewGuid().ToString("N")); // ignoring failure
-                Assert.Equal(1, GetMaxResponseDrainSize(handler));
-                Assert.Throws<InvalidOperationException>(() => SetMaxResponseDrainSize(handler, 1));
+                Assert.Equal(1, handler.MaxResponseDrainSize);
+                Assert.Throws<InvalidOperationException>(() => handler.MaxResponseDrainSize = 1);
             }
         }
 
@@ -145,7 +130,7 @@ await LoopbackServer.CreateClientAndServerAsync(
                 async url =>
                 {
                     var handler = new SocketsHttpHandler();
-                    SetMaxResponseDrainSize(handler, maxDrainSize);
+                    handler.MaxResponseDrainSize = maxDrainSize;
 
                     // Set MaxConnectionsPerServer to 1.  This will ensure we will wait for the previous request to drain (or fail to)
                     handler.MaxConnectionsPerServer = 1;
@@ -190,7 +175,7 @@ await LoopbackServer.CreateClientAndServerAsync(
                 async url =>
                 {
                     var handler = new SocketsHttpHandler();
-                    SetMaxResponseDrainSize(handler, maxDrainSize);
+                    handler.MaxResponseDrainSize = maxDrainSize;
 
                     // Set MaxConnectionsPerServer to 1.  This will ensure we will wait for the previous request to drain (or fail to)
                     handler.MaxConnectionsPerServer = 1;