Addresses #678 and #679

Author: Justin Kotalik

src/Microsoft.AspNetCore.Http.Abstractions/FragmentString.cs

@@ -107,21 +107,25 @@ public static FragmentString FromUriComponent(Uri uri)
 
         public bool Equals(FragmentString other)
         {
-            return string.Equals(_value, other._value);
+            if (!HasValue && !other.HasValue)
+            {
+                return true;
+            }
+            return string.Equals(_value, other._value, StringComparison.Ordinal);
         }
 
         public override bool Equals(object obj)
         {
             if (ReferenceEquals(null, obj))
             {
-                return false;
+                return !HasValue;
             }
             return obj is FragmentString && Equals((FragmentString)obj);
         }
 
         public override int GetHashCode()
         {
-            return (_value != null ? _value.GetHashCode() : 0);
+            return (!HasValue ? _value.GetHashCode() : 0);
         }
 
         public static bool operator ==(FragmentString left, FragmentString right)

src/Microsoft.AspNetCore.Http.Abstractions/HostString.cs

@@ -205,6 +205,10 @@ public static HostString FromUriComponent(Uri uri)
         /// <returns></returns>
         public bool Equals(HostString other)
         {
+            if (!HasValue && !other.HasValue)
+            {
+                return true;
+            }
             return string.Equals(_value, other._value, StringComparison.OrdinalIgnoreCase);
         }
 
@@ -217,7 +221,7 @@ public override bool Equals(object obj)
         {
             if (ReferenceEquals(null, obj))
             {
-                return false;
+                return !HasValue;
             }
             return obj is HostString && Equals((HostString)obj);
         }
@@ -228,7 +232,7 @@ public override bool Equals(object obj)
         /// <returns></returns>
         public override int GetHashCode()
         {
-            return (_value != null ? StringComparer.OrdinalIgnoreCase.GetHashCode(_value) : 0);
+            return (!HasValue ? StringComparer.OrdinalIgnoreCase.GetHashCode(_value) : 0);
         }
 
         /// <summary>

src/Microsoft.AspNetCore.Http.Abstractions/QueryString.cs

@@ -215,21 +215,25 @@ public QueryString Add(string name, string value)
 
         public bool Equals(QueryString other)
         {
-            return string.Equals(_value, other._value);
+            if (!HasValue && !other.HasValue)
+            {
+                return true;
+            }
+            return string.Equals(_value, other._value, StringComparison.Ordinal);
         }
 
         public override bool Equals(object obj)
         {
             if (ReferenceEquals(null, obj))
             {
-                return false;
+                return !HasValue;
             }
             return obj is QueryString && Equals((QueryString)obj);
         }
 
         public override int GetHashCode()
         {
-            return _value?.GetHashCode() ?? 0;
+            return (HasValue ? _value.GetHashCode() : 0);
         }
 
         public static bool operator ==(QueryString left, QueryString right)

src/Microsoft.AspNetCore.Http.Extensions/UriHelper.cs

@@ -11,6 +11,9 @@ namespace Microsoft.AspNetCore.Http.Extensions
     /// </summary>
     public static class UriHelper
     {
+        private const string ForwardSlash = "/";
+        private const string Pound = "#";
+        private const string QuestionMark = "?";
         private const string SchemeDelimiter = "://";
 
         /// <summary>
@@ -70,6 +73,91 @@ public static string BuildAbsolute(
                 .ToString();
         }
 
+        /// <summary>
+        /// Seperates the given absolute URI string into components. Assumes no PathBase.
+        /// </summary>
+        /// <param name="uri">A string representation of the uri.</param>
+        /// <param name="scheme">http, https, etc.</param>
+        /// <param name="host">The host portion of the uri normally included in the Host header. This may include the port.</param>
+        /// <param name="path">The portion of the request path that identifies the requested resource.</param>
+        /// <param name="query">The query, if any.</param>
+        /// <param name="fragment">The fragment, if any.</param>
+        public static void FromAbsolute(
+            string uri,
+            out string scheme,
+            out HostString host, 
+            out PathString path,
+            out QueryString query, 
+            out FragmentString fragment)
+        {
+            if (uri == null)
+            {
+                throw new ArgumentNullException(nameof(uri));
+            }
+            
+            // Satisfy the out parameters
+            path = new PathString();
+            query = new QueryString();
+            fragment = new FragmentString();
+
+            var schemeIndex = uri.IndexOf(SchemeDelimiter);
+            if (schemeIndex < 0)
+            {
+                throw new FormatException("No scheme delimiter in uri.");
+            }
+
+            scheme = uri.Substring(0, schemeIndex);
+
+            // PERF: Calculate the end of the scheme for next IndexOf
+            schemeIndex += SchemeDelimiter.Length;
+
+            // TODO Discuss URI without path/pathbase but with query/fragment
+            var hostIndex = uri.IndexOf(ForwardSlash, schemeIndex);
+
+            if (hostIndex < 0)
+            {
+                // Ex: http://example.com
+                host = new HostString(uri.Substring(schemeIndex));
+                return;
+            } 
+
+            // if trailing slash (http://example.com/, PathString will be created with slash, which is fine.
+            host = new HostString(uri.Substring(schemeIndex, hostIndex - schemeIndex));
+
+            var pathIndex = uri.IndexOf(QuestionMark, hostIndex);
+
+            if (pathIndex < 0)
+            {
+                // Means there is no query, look for fragment.
+                pathIndex = uri.IndexOf(Pound, hostIndex);
+                if (pathIndex < 0)
+                {
+                    // no fragment, create PathString out of rest of uri
+                    path = new PathString(uri.Substring(hostIndex));
+                }
+                else
+                {
+                    // make new PathString and FragmentString at found index
+                    path = new PathString(uri.Substring(hostIndex, pathIndex - hostIndex));
+                    fragment = new FragmentString(uri.Substring(pathIndex));
+                }
+                return;
+            }
+
+            path = new PathString(uri.Substring(hostIndex, pathIndex - hostIndex));
+
+            var queryIndex = uri.IndexOf(Pound, pathIndex);
+            if (queryIndex < 0)
+            {
+                // no fragment, create QueryString out of rest of uri
+                query = new QueryString(uri.Substring(pathIndex));
+                return;
+            }
+            // make new QueryString and FragmentString at found index
+            query = new QueryString(uri.Substring(pathIndex, queryIndex - pathIndex));
+            fragment = new FragmentString(uri.Substring(queryIndex));
+        }
+
         /// <summary>
         /// Generates a string from the given absolute or relative Uri that is appropriately encoded for use in
         /// HTTP headers. Note that a unicode host name will be encoded as punycode.

test/Microsoft.AspNetCore.Http.Abstractions.Tests/FragmentStringTests.cs

@@ -0,0 +1,42 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Xunit;
+
+namespace Microsoft.AspNetCore.Http.Abstractions.Tests
+{
+    public class FragmentStringTests
+    {
+        [Fact]
+        public void Equals_EmptyFragmentStringAndDefaultFragmentString()
+        {
+            // Act and Assert
+            Assert.Equal(FragmentString.Empty, default(FragmentString));
+            Assert.Equal(default(FragmentString), FragmentString.Empty);
+            Assert.True(FragmentString.Empty == default(FragmentString));
+            Assert.True(default(FragmentString) == FragmentString.Empty);
+            Assert.True(FragmentString.Empty.Equals(default(FragmentString)));
+            Assert.True(default(FragmentString).Equals(FragmentString.Empty));
+        }
+
+        [Fact]
+        public void NotEquals_DefaultFragmentStringAndNonNullFragmentString()
+        {
+            // Arrange
+            var fragmentString = new FragmentString("#col=1");
+
+            // Act and Assert
+            Assert.NotEqual(fragmentString, default(FragmentString));
+        }
+
+        [Fact]
+        public void NotEquals_EmptyFragmentStringAndNonNullFragmentString()
+        {
+            // Arrange
+            var fragmentString = new FragmentString("#col=1");
+
+            // Act and Assert
+            Assert.NotEqual(fragmentString, FragmentString.Empty);
+        }
+    }
+}

test/Microsoft.AspNetCore.Http.Abstractions.Tests/HostStringTest.cs

@@ -92,5 +92,37 @@ public void Ctor_CreatesFromHostAndPort(string sourceHost, int sourcePort, strin
             Assert.Equal(expectedHost, host);
             Assert.Equal(expectedPort, port);
         }
+
+        [Fact]
+        public void Equals_EmptyHostStringAndDefaultHostString()
+        {
+            // Act and Assert
+            Assert.Equal(new HostString(string.Empty), default(HostString));
+            Assert.Equal(default(HostString), new HostString(string.Empty));
+            Assert.True(new HostString(string.Empty) == default(HostString));
+            Assert.True(default(HostString) == new HostString(string.Empty));
+            Assert.True(new HostString(string.Empty).Equals(default(HostString)));
+            Assert.True(default(HostString).Equals(new HostString(string.Empty)));
+        }
+
+        [Fact]
+        public void NotEquals_DefaultHostStringAndNonNullHostString()
+        {
+            // Arrange
+            var hostString = new HostString("example.com");
+
+            // Act and Assert
+            Assert.NotEqual(hostString, default(HostString));
+        }
+
+        [Fact]
+        public void NotEquals_EmptyHostStringAndNonNullHostString()
+        {
+            // Arrange
+            var hostString = new HostString("example.com");
+
+            // Act and Assert
+            Assert.NotEqual(hostString, new HostString(string.Empty));
+        }
     }
 }

test/Microsoft.AspNetCore.Http.Abstractions.Tests/QueryStringTests.cs

@@ -105,5 +105,37 @@ public void AddNameValue_Success(string query1, string name2, string value2, str
             var q2 = q1.Add(name2, value2);
             Assert.Equal(expected, q2.Value);
         }
+
+        [Fact]
+        public void Equals_EmptyQueryStringAndDefaultQueryString()
+        {
+            // Act and Assert
+            Assert.Equal(QueryString.Empty, default(QueryString));
+            Assert.Equal(default(QueryString), QueryString.Empty);
+            Assert.True(QueryString.Empty == default(QueryString));
+            Assert.True(default(QueryString) == QueryString.Empty);
+            Assert.True(QueryString.Empty.Equals(default(QueryString)));
+            Assert.True(default(QueryString).Equals(QueryString.Empty));
+        }
+
+        [Fact]
+        public void NotEquals_DefaultQueryStringAndNonNullQueryString()
+        {
+            // Arrange
+            var queryString = new QueryString("?foo=1");
+
+            // Act and Assert
+            Assert.NotEqual(queryString, default(QueryString));
+        }
+
+        [Fact]
+        public void NotEquals_EmptyQueryStringAndNonNullQueryString()
+        {
+            // Arrange
+            var queryString = new QueryString("?foo=1");
+
+            // Act and Assert
+            Assert.NotEqual(queryString, QueryString.Empty);
+        }
     }
 }

test/Microsoft.AspNetCore.Http.Extensions.Tests/UriHelperTests.cs

@@ -66,5 +66,34 @@ public void GetDisplayUrlFromRequest()
 
             Assert.Equal("http://my.hoψst:80/un?escaped/base/un?escaped?name=val%23ue", request.GetDisplayUrl());
         }
+
+        [Theory]
+        [InlineData("http://example.com", "http", "example.com", "", "", "")]
+        [InlineData("https://example.com", "https", "example.com", "", "", "")]
+        [InlineData("http://example.com/foo/bar", "http", "example.com", "/foo/bar", "", "")]
+        [InlineData("http://example.com/foo/bar?baz=1", "http", "example.com", "/foo/bar", "?baz=1", "")]
+        [InlineData("http://example.com/foo#col=2", "http", "example.com", "/foo", "", "#col=2")]
+        [InlineData("http://example.com/foo?bar=1#col=2", "http", "example.com", "/foo", "?bar=1", "#col=2")]
+        public void FromAbsoluteUriParsingChecks(
+            string uri, 
+            string expectedScheme, 
+            string expectedHost, 
+            string expectedPath, 
+            string expectedQuery, 
+            string expectedFragment)
+        {
+            string scheme = null;
+            var host = new HostString();
+            var path = new PathString();
+            var query = new QueryString();
+            var fragment = new FragmentString();
+            UriHelper.FromAbsolute(uri, out scheme, out host, out path, out query, out fragment);
+
+            Assert.Equal(scheme, expectedScheme);
+            Assert.Equal(host, new HostString(expectedHost));
+            Assert.Equal(path, new PathString(expectedPath));
+            Assert.Equal(query, new QueryString(expectedQuery));
+            Assert.Equal(fragment, new FragmentString(expectedFragment));
+        }
     }
 }