[browser][wasm] Configuring request options in Browser WebAssembly (d…

…otnet#39182) * [browser][wasm] Initial addition of configuring request options in Browser WebAssembly * Fix key code. Not what was proposed * Add TryGetValue<TValue> and Set<TValue> as per proposal * Add missing obsolete attribute * Address review comments * Update tests to use Options and not obsolete Properties. * Implement IDictionary<string, object?> explicitly * Update tests to use Options and not obsolete Properties. * Add HttpRequestOptions source to the System.Net.Http.Unit.Tests project to fix build. * Address review comments - explicit * Fix build error cannot convert from 'string' to 'System.Net.Http.HttpRequestOptionsKey<object>' * Add tests for HttpRequestOptions * Fix test build * Add special case code for NETFRAMEWORK for API change. * #endif out of place fix * #endif out of place fix
Jacksondr5 · Aug 10, 2020 · 1997332 · 1997332
1 parent 86088b2
commit 1997332
Show file tree

Hide file tree

Showing 11 changed files with 591 additions and 18 deletions.
diff --git a/...nsions.Http/tests/DependencyInjection/HttpClientFactoryServiceCollectionExtensionsTest.cs b/...nsions.Http/tests/DependencyInjection/HttpClientFactoryServiceCollectionExtensionsTest.cs
@@ -948,13 +948,26 @@ public async Task AddHttpClient_MessageHandler_SingletonDependency()
             var request = new HttpRequestMessage(HttpMethod.Get, "http://example.com/");
             var response = await client.HttpClient.SendAsync(request);
 
+#if NETFRAMEWORK
             Assert.Same(
                 services.GetRequiredService<SingletonService>(),
                 request.Properties[nameof(SingletonService)]);
 
             Assert.Same(
                 client.Service,
                 request.Properties[nameof(SingletonService)]);
+#else
+#nullable enable
+            request.Options.TryGetValue(new HttpRequestOptionsKey<SingletonService>(nameof(SingletonService)), out SingletonService? optService);
+#nullable disable
+            Assert.Same(
+                services.GetRequiredService<SingletonService>(),
+                optService);
+
+            Assert.Same(
+                client.Service,
+                optService);
+#endif
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
@@ -979,6 +992,7 @@ public async Task AddHttpClient_MessageHandler_Scope_SingletonDependency()
                 var request = new HttpRequestMessage(HttpMethod.Get, "http://example.com/");
                 var response = await client.HttpClient.SendAsync(request);
 
+#if NETFRAMEWORK
                 Assert.Same(
                     services.GetRequiredService<SingletonService>(),
                     request.Properties[nameof(SingletonService)]);
@@ -990,6 +1004,23 @@ public async Task AddHttpClient_MessageHandler_Scope_SingletonDependency()
                 Assert.Same(
                     client.Service,
                     request.Properties[nameof(SingletonService)]);
+#else
+#nullable enable
+                request.Options.TryGetValue(new HttpRequestOptionsKey<SingletonService>(nameof(SingletonService)), out SingletonService? optService);
+#nullable disable
+
+                Assert.Same(
+                    services.GetRequiredService<SingletonService>(),
+                    optService);
+
+                Assert.Same(
+                    scope.ServiceProvider.GetRequiredService<SingletonService>(),
+                    optService);
+
+                Assert.Same(
+                    client.Service,
+                    optService);
+#endif
             }
         }
 
@@ -1035,6 +1066,7 @@ public async Task AddHttpClient_MessageHandler_Scope_ScopedDependency()
                 var request = new HttpRequestMessage(HttpMethod.Get, "http://example.com/");
                 var response = await client.HttpClient.SendAsync(request);
 
+#if NETFRAMEWORK
                 Assert.NotSame(
                     scope.ServiceProvider.GetRequiredService<ScopedService>(),
                     request.Properties[nameof(ScopedService)]);
@@ -1046,6 +1078,22 @@ public async Task AddHttpClient_MessageHandler_Scope_ScopedDependency()
                 Assert.NotSame(
                     client.Service,
                     request.Properties[nameof(ScopedService)]);
+#else
+#nullable enable
+                request.Options.TryGetValue(new HttpRequestOptionsKey<ScopedService>(nameof(ScopedService)), out ScopedService? optService);
+#nullable disable
+                Assert.NotSame(
+                    scope.ServiceProvider.GetRequiredService<ScopedService>(),
+                    optService);
+
+                Assert.Same(
+                    scope.ServiceProvider.GetRequiredService<ScopedService>(),
+                    client.Service);
+
+                Assert.NotSame(
+                    client.Service,
+                    optService);
+#endif
             }
         }
 
@@ -1069,13 +1117,26 @@ public async Task AddHttpClient_MessageHandler_TransientDependency()
             var request = new HttpRequestMessage(HttpMethod.Get, "http://example.com/");
             var response = await client.HttpClient.SendAsync(request);
 
+#if NETFRAMEWORK
             Assert.NotSame(
                 services.GetRequiredService<TransientService>(),
                 request.Properties[nameof(TransientService)]);
 
             Assert.NotSame(
                 client.Service,
                 request.Properties[nameof(TransientService)]);
+#else
+#nullable enable
+            request.Options.TryGetValue(new HttpRequestOptionsKey<TransientService>(nameof(TransientService)), out TransientService? optService);
+#nullable disable
+            Assert.NotSame(
+                services.GetRequiredService<TransientService>(),
+                optService);
+
+            Assert.NotSame(
+                client.Service,
+                optService);
+#endif
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
@@ -1100,13 +1161,26 @@ public async Task AddHttpClient_MessageHandler_Scope_TransientDependency()
                 var request = new HttpRequestMessage(HttpMethod.Get, "http://example.com/");
                 var response = await client.HttpClient.SendAsync(request);
 
+#if NETFRAMEWORK
                 Assert.NotSame(
                     services.GetRequiredService<TransientService>(),
                     request.Properties[nameof(TransientService)]);
 
                 Assert.NotSame(
                     client.Service,
                     request.Properties[nameof(TransientService)]);
+#else
+#nullable enable
+            request.Options.TryGetValue(new HttpRequestOptionsKey<TransientService>(nameof(TransientService)), out TransientService? optService);
+#nullable disable
+                Assert.NotSame(
+                    services.GetRequiredService<TransientService>(),
+                    optService);
+
+                Assert.NotSame(
+                    client.Service,
+                    optService);
+#endif
             }
         }
 
@@ -1304,7 +1378,11 @@ public HandlerWithSingletonService(SingletonService service)
 
             protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
             {
+#if NETFRAMEWORK
                 request.Properties[nameof(SingletonService)] = Service;
+#else
+                request.Options.Set(new HttpRequestOptionsKey<SingletonService>(nameof(SingletonService)), Service);
+#endif
                 return Task.FromResult(new HttpResponseMessage());
             }
         }
@@ -1320,7 +1398,11 @@ public HandlerWithScopedService(ScopedService service)
 
             protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
             {
+#if NETFRAMEWORK
                 request.Properties[nameof(ScopedService)] = Service;
+#else                
+                request.Options.Set(new HttpRequestOptionsKey<ScopedService>(nameof(ScopedService)), Service);
+#endif
                 return Task.FromResult(new HttpResponseMessage());
             }
         }
@@ -1336,7 +1418,11 @@ public HandlerWithTransientService(TransientService service)
 
             protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
             {
+#if NETFRAMEWORK
                 request.Properties[nameof(TransientService)] = Service;
+#else
+                request.Options.Set(new HttpRequestOptionsKey<TransientService>(nameof(TransientService)), Service);
+#endif
                 return Task.FromResult(new HttpResponseMessage());
             }
         }

diff --git a/src/libraries/System.Net.Http/ref/System.Net.Http.cs b/src/libraries/System.Net.Http/ref/System.Net.Http.cs
@@ -4,6 +4,8 @@
 // Changes to this file must follow the https://aka.ms/api-review process.
 // ------------------------------------------------------------------------------
 
+using System.Diagnostics.CodeAnalysis;
+
 namespace System.Net.Http
 {
     public partial class ByteArrayContent : System.Net.Http.HttpContent
@@ -212,13 +214,44 @@ public HttpRequestMessage(System.Net.Http.HttpMethod method, System.Uri? request
         public System.Net.Http.HttpContent? Content { get { throw null; } set { } }
         public System.Net.Http.Headers.HttpRequestHeaders Headers { get { throw null; } }
         public System.Net.Http.HttpMethod Method { get { throw null; } set { } }
+        [Obsolete("Use Options instead.")]
         public System.Collections.Generic.IDictionary<string, object?> Properties { get { throw null; } }
+        public HttpRequestOptions Options { get { throw null; } }
         public System.Uri? RequestUri { get { throw null; } set { } }
         public System.Version Version { get { throw null; } set { } }
         public void Dispose() { }
         protected virtual void Dispose(bool disposing) { }
         public override string ToString() { throw null; }
     }
+
+    public readonly struct HttpRequestOptionsKey<TValue>
+    {
+        public HttpRequestOptionsKey(string key) {}
+        public string Key { get { throw null; } }
+    }
+
+    public sealed class HttpRequestOptions : System.Collections.Generic.IDictionary<string, object?>
+    {
+        void System.Collections.Generic.IDictionary<string, object?>.Add(string key, object? value) { throw null; }
+        System.Collections.Generic.ICollection<string> System.Collections.Generic.IDictionary<string, object?>.Keys { get { throw null; } }
+        System.Collections.Generic.ICollection<object?> System.Collections.Generic.IDictionary<string, object?>.Values { get { throw null; } }
+        bool System.Collections.Generic.IDictionary<string, object?>.Remove(string key) { throw null; }
+        bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<string, object?>>.Remove(System.Collections.Generic.KeyValuePair<string, object?> item) { throw null; }
+        bool System.Collections.Generic.IDictionary<string, object?>.TryGetValue(string key, out object? value) { throw null; }
+        object? System.Collections.Generic.IDictionary<string, object?>.this[string key] { get { throw null; } set { } }
+        void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<string, object?>>.Add(System.Collections.Generic.KeyValuePair<string, object?> item) { throw null; }
+        void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<string, object?>>.Clear() { throw null; }
+        bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<string, object?>>.Contains(System.Collections.Generic.KeyValuePair<string, object?> item) { throw null; }
+        bool System.Collections.Generic.IDictionary<string, object?>.ContainsKey(string key) { throw null; }
+        void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<string, object?>>.CopyTo(System.Collections.Generic.KeyValuePair<string, object?>[] array, int arrayIndex) { throw null; }
+        int System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<string, object?>>.Count { get { throw null; } }
+        bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<string, object?>>.IsReadOnly { get { throw null; } }
+        System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<string, object?>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, object?>>.GetEnumerator() { throw null; }
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
+        public bool TryGetValue<TValue>(HttpRequestOptionsKey<TValue> key, [MaybeNullWhen(false)] out TValue value) { throw null; }
+        public void Set<TValue>(HttpRequestOptionsKey<TValue> key, TValue value) { throw null; }
+    }
+
     public partial class HttpResponseMessage : System.IDisposable
     {
         public HttpResponseMessage() { }

diff --git a/src/libraries/System.Net.Http/src/System.Net.Http.csproj b/src/libraries/System.Net.Http/src/System.Net.Http.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <WindowsRID>win</WindowsRID>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
@@ -45,6 +45,8 @@
     <Compile Include="System\Net\Http\HttpParseResult.cs" />
     <Compile Include="System\Net\Http\HttpRequestException.cs" />
     <Compile Include="System\Net\Http\HttpRequestMessage.cs" />
+    <Compile Include="System\Net\Http\HttpRequestOptions.cs" />
+    <Compile Include="System\Net\Http\HttpRequestOptionsKey.cs" />
     <Compile Include="System\Net\Http\HttpResponseMessage.cs" />
     <Compile Include="System\Net\Http\HttpRuleParser.cs" />
     <Compile Include="System\Net\Http\HttpTelemetry.cs" />

diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/BrowserHttpHandler/BrowserHttpHandler.cs b/src/libraries/System.Net.Http/src/System/Net/Http/BrowserHttpHandler/BrowserHttpHandler.cs
@@ -32,6 +32,9 @@ internal sealed class BrowserHttpHandler : HttpMessageHandler
         private static readonly JSObject? s_fetch = (JSObject)System.Runtime.InteropServices.JavaScript.Runtime.GetGlobalObject("fetch");
         private static readonly JSObject? s_window = (JSObject)System.Runtime.InteropServices.JavaScript.Runtime.GetGlobalObject("window");
 
+        private static readonly HttpRequestOptionsKey<bool> EnableStreamingResponse = new HttpRequestOptionsKey<bool>("WebAssemblyEnableStreamingResponse");
+        private static readonly HttpRequestOptionsKey<IDictionary<string, object>> FetchOptions = new HttpRequestOptionsKey<IDictionary<string, object>>("WebAssemblyFetchOptions");
+
         /// <summary>
         /// Gets whether the current Browser supports streaming responses
         /// </summary>
@@ -133,8 +136,7 @@ protected internal override async Task<HttpResponseMessage> SendAsync(HttpReques
             {
                 var requestObject = new JSObject();
 
-                if (request.Properties.TryGetValue("WebAssemblyFetchOptions", out object? fetchOptionsValue) &&
-                    fetchOptionsValue is IDictionary<string, object> fetchOptions)
+                if (request.Options.TryGetValue(FetchOptions, out IDictionary<string, object>? fetchOptions))
                 {
                     foreach (KeyValuePair<string, object> item in fetchOptions)
                     {
@@ -225,9 +227,13 @@ protected internal override async Task<HttpResponseMessage> SendAsync(HttpReques
 
                 HttpResponseMessage httpResponse = new HttpResponseMessage((HttpStatusCode)status.Status);
 
-                bool streamingEnabled = request.Properties.TryGetValue("WebAssemblyEnableStreamingResponse", out object? streamingEnabledValue) && (bool)(streamingEnabledValue ?? false);
+                bool streamingEnabled = false;
+                if (StreamingSupported)
+                {
+                    request.Options.TryGetValue(EnableStreamingResponse, out streamingEnabled);
+                }
 
-                httpResponse.Content = StreamingSupported && streamingEnabled
+                httpResponse.Content = streamingEnabled
                     ? new StreamContent(wasmHttpReadStream = new WasmHttpReadStream(status))
                     : (HttpContent)new BrowserHttpContent(status);
 

diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/HttpRequestMessage.cs b/src/libraries/System.Net.Http/src/System/Net/Http/HttpRequestMessage.cs
@@ -24,7 +24,7 @@ public class HttpRequestMessage : IDisposable
         private Version _version;
         private HttpContent? _content;
         private bool _disposed;
-        private IDictionary<string, object?>? _properties;
+        private HttpRequestOptions? _options;
 
         public Version Version
         {
@@ -111,17 +111,10 @@ public HttpRequestHeaders Headers
 
         internal bool HasHeaders => _headers != null;
 
-        public IDictionary<string, object?> Properties
-        {
-            get
-            {
-                if (_properties == null)
-                {
-                    _properties = new Dictionary<string, object?>();
-                }
-                return _properties;
-            }
-        }
+        [Obsolete("Use Options instead.")]
+        public IDictionary<string, object?> Properties => Options;
+
+        public HttpRequestOptions Options => _options ??= new HttpRequestOptions();
 
         public HttpRequestMessage()
             : this(HttpMethod.Get, (Uri?)null)

diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/HttpRequestOptions.cs b/src/libraries/System.Net.Http/src/System/Net/Http/HttpRequestOptions.cs
@@ -0,0 +1,56 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+namespace System.Net.Http
+{
+    public sealed class HttpRequestOptions : IDictionary<string, object?>
+    {
+        private Dictionary<string, object?> Options { get; } = new Dictionary<string, object?>();
+        object? IDictionary<string, object?>.this[string key]
+        {
+            get
+            {
+                return Options[key];
+            }
+            set
+            {
+                Options[key] = value;
+            }
+        }
+        ICollection<string> IDictionary<string, object?>.Keys => Options.Keys;
+        ICollection<object?> IDictionary<string, object?>.Values => Options.Values;
+        int ICollection<KeyValuePair<string, object?>>.Count => Options.Count;
+        bool ICollection<KeyValuePair<string, object?>>.IsReadOnly => ((IDictionary<string, object?>)Options).IsReadOnly;
+        void IDictionary<string, object?>.Add(string key, object? value) => Options.Add(key, value);
+        void ICollection<KeyValuePair<string, object?>>.Add(KeyValuePair<string, object?> item) => ((IDictionary<string, object?>)Options).Add(item);
+        void ICollection<KeyValuePair<string, object?>>.Clear() => Options.Clear();
+        bool ICollection<KeyValuePair<string, object?>>.Contains(KeyValuePair<string, object?> item) => ((IDictionary<string, object?>)Options).Contains(item);
+        bool IDictionary<string, object?>.ContainsKey(string key) => Options.ContainsKey(key);
+        void ICollection<KeyValuePair<string, object?>>.CopyTo(KeyValuePair<string, object?>[] array, int arrayIndex) =>
+            ((IDictionary<string, object?>)Options).CopyTo(array, arrayIndex);
+        IEnumerator<KeyValuePair<string, object?>> IEnumerable<KeyValuePair<string, object?>>.GetEnumerator() => Options.GetEnumerator();
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => ((System.Collections.IEnumerable)Options).GetEnumerator();
+        bool IDictionary<string, object?>.Remove(string key) => Options.Remove(key);
+        bool ICollection<KeyValuePair<string, object?>>.Remove(KeyValuePair<string, object?> item) => ((IDictionary<string, object?>)Options).Remove(item);
+        bool IDictionary<string, object?>.TryGetValue(string key, out object? value) => Options.TryGetValue(key, out value);
+        public bool TryGetValue<TValue>(HttpRequestOptionsKey<TValue> key, [MaybeNullWhen(false)] out TValue value)
+        {
+            if (Options.TryGetValue(key.Key, out object? _value) && _value is TValue tvalue)
+            {
+                value = tvalue;
+                return true;
+            }
+
+            value = default(TValue);
+            return false;
+        }
+
+        public void Set<TValue>(HttpRequestOptionsKey<TValue> key, TValue value)
+        {
+            Options[key.Key] = value;
+        }
+    }
+}
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/HttpRequestOptionsKey.cs b/src/libraries/System.Net.Http/src/System/Net/Http/HttpRequestOptionsKey.cs
@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+namespace System.Net.Http
+{
+    public readonly struct HttpRequestOptionsKey<TValue>
+    {
+        public string Key { get; }
+        public HttpRequestOptionsKey(string key)
+        {
+            Key = key;
+        }
+    }
+}
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpRequestMessageTest.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpRequestMessageTest.cs
@@ -154,7 +154,7 @@ public void Properties_SetPropertiesAndGetTheirValue_MatchingValues()
             Assert.Equal(version, rm.Version);
 
             Assert.NotNull(rm.Headers);
-            Assert.NotNull(rm.Properties);
+            Assert.NotNull(rm.Options);
         }
 
         [Fact]