Added HttpContent.ReadAsFormData helper for reading form data and return a NameValueCollection. The helper is a thin wrapper around existing functionality but saves a couple of lines for the developer to write.

Author: henrikn

src/System.Net.Http.Formatting/HttpContentFormDataExtensions.cs

@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Net.Http.Formatting;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
+using System.Web.Http;
+
+namespace System.Net.Http
+{
+    /// <summary>
+    /// Extension methods to allow HTML form URL-encoded data, also known as <c>application/x-www-form-urlencoded</c>, 
+    /// to be read from <see cref="HttpContent"/> instances.
+    /// </summary>
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public static class HttpContentFormDataExtensions
+    {
+        private const string ApplicationFormUrlEncoded = "application/x-www-form-urlencoded";
+
+        /// <summary>
+        /// Determines whether the specified content is HTML form URL-encoded data, also known as <c>application/x-www-form-urlencoded</c> data.
+        /// </summary>
+        /// <param name="content">The content.</param>
+        /// <returns>
+        /// <c>true</c> if the specified content is HTML form URL-encoded data; otherwise, <c>false</c>.
+        /// </returns>
+        public static bool IsFormData(this HttpContent content)
+        {
+            if (content == null)
+            {
+                throw Error.ArgumentNull("content");
+            }
+
+            MediaTypeHeaderValue contentType = content.Headers.ContentType;
+            return contentType != null && String.Equals(ApplicationFormUrlEncoded, contentType.MediaType, StringComparison.OrdinalIgnoreCase);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Task{T}"/> that will yield a <see cref="NameValueCollection"/> instance containing the form data
+        /// from the <paramref name="content"/> instance.
+        /// </summary>
+        /// <param name="content">The content.</param>
+        /// <returns>A <see cref="Task{T}"/> which will provide the result.</returns>
+        public static Task<NameValueCollection> ReadAsFormDataAsync(this HttpContent content)
+        {
+            if (content == null)
+            {
+                throw Error.ArgumentNull("content");
+            }
+
+            return content.ReadAsAsync<FormDataCollection>()
+                .Then(formdata => formdata != null ? formdata.ReadAsNameValueCollection() : null);
+        }
+    }
+}

src/System.Net.Http.Formatting/System.Net.Http.Formatting.csproj

@@ -88,6 +88,7 @@
       <Link>Properties\TransparentCommonAssemblyInfo.cs</Link>
     </Compile>
     <Compile Include="CloneableExtensions.cs" />
+    <Compile Include="HttpContentFormDataExtensions.cs" />
     <Compile Include="MultipartRelatedStreamProvider.cs" />
     <Compile Include="MultipartFileData.cs" />
     <Compile Include="MultipartStreamProvider.cs" />

test/System.Net.Http.Formatting.Test.Unit/HttpContentFormDataExtensionsTest.cs

@@ -0,0 +1,163 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Specialized;
+using System.Net.Http.Formatting;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.TestCommon;
+using Xunit;
+using Xunit.Extensions;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace System.Net.Http
+{
+    public class HttpContentFormDataExtensionsTest
+    {
+        public static TheoryDataSet<string> FormDataContentTypes
+        {
+            get
+            {
+                return new TheoryDataSet<string>
+                {
+                    "application/x-www-form-urlencoded",
+                    "APPLICATION/x-www-form-urlencoded",
+                    "application/X-WWW-FORM-URLENCODED",
+                    "application/x-www-form-urlencoded; charset=utf-8",
+                    "application/x-www-form-urlencoded; parameter=value",
+                };
+            }
+        }
+
+        public static TheoryDataSet<string> NonFormDataContentTypes
+        {
+            get
+            {
+                return new TheoryDataSet<string>
+                {
+                    "application/xml",
+                    "APPLICATION/json",
+                    "text/xml",
+                    "text/xml; charset=utf-8",
+                    "text/xml; parameter=value",
+                };
+            }
+        }
+
+        public static TheoryDataSet<string> FormData
+        {
+            get
+            {
+                return new TheoryDataSet<string>
+                {
+                    "a=b",
+                    "a+c=d+e",
+                    "n1=v1&n2=v2",
+                    "n1=v1a+v1b&n2=v2a+v2b",
+                    "N=%c3%a6%c3%b8%c3%a5",
+                };
+            }
+        }
+
+        public static TheoryDataSet<string> IrregularFormData
+        {
+            get
+            {
+                return new TheoryDataSet<string>
+                {
+                    "?data",
+                    Char.ConvertFromUtf32(0x0D),
+                    "Hello World",
+                    "<string>Hello World</string>",
+                    "{ \"Message\" : \"Hello World\"",
+                };
+            }
+        }
+
+        [Fact]
+        public void IsFormData_ThrowsOnNull()
+        {
+            Assert.ThrowsArgumentNull(() => HttpContentFormDataExtensions.IsFormData(null), "content");
+        }
+
+        [Fact]
+        public void IsFormData_HandlesNullContentType()
+        {
+            HttpContent content = new StringContent(String.Empty);
+            content.Headers.ContentType = null;
+            Assert.False(content.IsFormData());
+        }
+
+        [Theory]
+        [PropertyData("FormDataContentTypes")]
+        public void IsFormData_AcceptsFormDataMediaTypes(string mediaType)
+        {
+            HttpContent content = new StringContent(String.Empty);
+            content.Headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
+            Assert.True(content.IsFormData());
+        }
+
+        [Theory]
+        [PropertyData("NonFormDataContentTypes")]
+        public void IsFormData_RejectsNonFormDataMediaTypes(string mediaType)
+        {
+            HttpContent content = new StringContent(String.Empty);
+            content.Headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
+            Assert.False(content.IsFormData());
+        }
+
+        [Fact]
+        public void ReadAsFormDataAsync_ThrowsOnNull()
+        {
+            Assert.ThrowsArgumentNull(() => HttpContentFormDataExtensions.ReadAsFormDataAsync(null), "content");
+        }
+
+        [Theory]
+        [PropertyData("FormData")]
+        public Task ReadAsFormDataAsync_HandlesFormData(string formData)
+        {
+            // Arrange
+            HttpContent content = new StringContent(formData);
+            content.Headers.ContentType = MediaTypeConstants.ApplicationFormUrlEncodedMediaType;
+
+            // Act
+            return content.ReadAsFormDataAsync().ContinueWith(
+                readTask =>
+                {
+                    NameValueCollection data = readTask.Result;
+
+                    // Assert
+                    Assert.Equal(TaskStatus.RanToCompletion, readTask.Status);
+                    Assert.Equal(formData, data.ToString());
+                });
+        }
+
+        [Theory]
+        [PropertyData("IrregularFormData")]
+        public Task ReadAsFormDataAsync_HandlesIrregularFormData(string irregularFormData)
+        {
+            // Arrange
+            HttpContent content = new StringContent(irregularFormData);
+            content.Headers.ContentType = MediaTypeConstants.ApplicationFormUrlEncodedMediaType;
+
+            // Act
+            return content.ReadAsFormDataAsync().ContinueWith(
+                readTask =>
+                {
+                    NameValueCollection data = readTask.Result;
+
+                    // Assert
+                    Assert.Equal(TaskStatus.RanToCompletion, readTask.Status);
+                    Assert.Equal(1, data.Count);
+                    Assert.Equal(irregularFormData, data.AllKeys[0]);
+                });
+        }
+
+        [Fact]
+        public void ReadAsFormDataAsync_HandlesNonFormData()
+        {
+            HttpContent content = new StringContent(String.Empty, Encoding.UTF8, "test/unknown");
+            Assert.Throws<InvalidOperationException>(() => content.ReadAsFormDataAsync());
+        }
+    }
+}

test/System.Net.Http.Formatting.Test.Unit/System.Net.Http.Formatting.Test.Unit.csproj

@@ -86,6 +86,7 @@
     <Compile Include="..\Common\UriQueryUtilityTest.cs">
       <Link>Common\UriQueryUtilityTest.cs</Link>
     </Compile>
+    <Compile Include="HttpContentFormDataExtensionsTest.cs" />
     <Compile Include="PushStreamContentTest.cs" />
     <Compile Include="HttpClientFactoryTest.cs" />
     <Compile Include="Handlers\ProgressContentTest.cs" />