public string String_Create(HostString hostString, PathString pathBaseString, PathString pathString, QueryString queryString, FragmentString fragmentString)
{
var scheme = "https";
var host = hostString.ToUriComponent();
var pathBase = pathBaseString.ToUriComponent();
var path = pathString.ToUriComponent();
var query = queryString.ToUriComponent();
var fragment = fragmentString.ToUriComponent();
// PERF: Calculate string length to allocate correct buffer size for string.Create.
var length =
scheme.Length +
Uri.SchemeDelimiter.Length +
host.Length +
pathBase.Length +
path.Length +
query.Length +
fragment.Length;
if (string.IsNullOrEmpty(pathBase) && string.IsNullOrEmpty(path))
{
path = "/";
length++;
}
return(string.Create(length, (scheme, host, pathBase, path, query, fragment), initializeStringSpanAction));
}
private bool HandleNonHstsRequest(HttpContext context)
{
bool handleNonHstsRequest = (_policy.Hsts != null) && !context.Request.IsHttps;
if (handleNonHstsRequest)
{
if (!String.Equals(context.Request.Method, "GET", StringComparison.OrdinalIgnoreCase) && !String.Equals(context.Request.Method, "HEAD", StringComparison.OrdinalIgnoreCase))
{
context.Response.StatusCode = StatusCodes.Status403Forbidden;
}
else
{
HostString host = (_policy.SslPort.HasValue && (_policy.SslPort > 0)) ? new HostString(context.Request.Host.Host, _policy.SslPort.Value) : new HostString(context.Request.Host.Host);
string location = String.Concat("https://",
host.ToUriComponent(),
context.Request.PathBase.ToUriComponent(),
context.Request.Path.ToUriComponent(),
context.Request.QueryString.ToUriComponent());
context.Response.Redirect(location, true);
}
}
return(handleNonHstsRequest);
}
private string ResourceBaseUrl()
{
HostString host = this.httpContextAccessor.HttpContext.Request.Host;
string uriProto = this.httpContextAccessor.HttpContext.Request.IsHttps ? "https://" : "http://";
return(uriProto + host.ToUriComponent() + this.httpContextAccessor.HttpContext.Request.Path);
}
public string StringBuilderWithoutBoxing(HostString host, PathString basePath, PathString path, QueryString query)
=> new StringBuilder()
.Append("https://")
.Append(host.ToUriComponent())
.Append(basePath.ToUriComponent())
.Append(path.ToUriComponent())
.Append(query.ToUriComponent())
.ToString();
public void ConstructHostUriUsingUriBuilder()
{
// arrange
string expectedScheme = "http";
var expectedHostString = new HostString("localhost", 3333);
// apply
string absoluteHostUri = UriHelper.BuildAbsolute(expectedScheme, expectedHostString)
.RemoveSlashFromEnd();
// assert
expectedHostString.ToUriComponent().Should().NotContain(expectedScheme);
absoluteHostUri.Should().Be($"{expectedScheme}://{expectedHostString}");
}
public string Crazy1(HostString host, PathString basePath, PathString path, QueryString query)
{
var uriParts = (
scheme : "https://",
host : host.ToUriComponent(),
basePath : basePath.ToUriComponent(),
path : path.ToUriComponent(),
query : query.ToUriComponent());
var length = uriParts.scheme.Length + uriParts.host.Length + uriParts.basePath.Length + uriParts.path.Length + uriParts.query.Length;
return(string.Create(
length,
uriParts,
(buffer, uriParts) =>
{
var i = -1;
foreach (var c in uriParts.scheme)
{
buffer[++i] = c;
}
foreach (var c in uriParts.host)
{
buffer[++i] = c;
}
if (uriParts.basePath.Length != 0)
{
foreach (var c in uriParts.basePath)
{
buffer[++i] = c;
}
}
foreach (var c in uriParts.path)
{
buffer[++i] = c;
}
if (uriParts.query.Length != 0)
{
foreach (var c in uriParts.query)
{
buffer[++i] = c;
}
}
}));
}
public string String_Concat_WithArrayArgument(HostString host, PathString pathBase, PathString path, QueryString query, FragmentString fragment)
{
var scheme = "https";
var SchemeDelimiter = Uri.SchemeDelimiter;
if (!pathBase.HasValue && !path.HasValue)
{
return(scheme + SchemeDelimiter + "/" + host.ToUriComponent() + "/" + query.ToUriComponent() + fragment.ToUriComponent());
}
else
{
return(scheme + SchemeDelimiter + pathBase.ToUriComponent() + path.ToUriComponent() + host.ToUriComponent() + "/" + query.ToUriComponent() + fragment.ToUriComponent());
}
}
public string Crazy2(HostString host, PathString basePath, PathString path, QueryString query)
{
const string httpsSchemePrefix = "https://";
const int httpsSchemePrefixLength = 8;
Debug.Assert(httpsSchemePrefix.Length == httpsSchemePrefixLength, "{nameof(httpsSchemePrefixLength)} should be {httpsSchemePrefix.Length} and is {httpsSchemePrefixLength}");
var uriParts = (
host : host.ToUriComponent(),
basePath : basePath.ToUriComponent(),
path : path.ToUriComponent(),
query : query.ToUriComponent());
var length = httpsSchemePrefixLength + uriParts.host.Length + uriParts.basePath.Length + uriParts.path.Length + uriParts.query.Length;
return(string.Create(
length,
uriParts,
(buffer, uriParts) =>
{
var span = httpsSchemePrefix.AsSpan();
span.CopyTo(buffer);
var i = httpsSchemePrefixLength;
span = uriParts.host.AsSpan();
span.CopyTo(buffer.Slice(i, span.Length));
i += span.Length;
if (uriParts.basePath.Length != 0)
{
span = uriParts.basePath.AsSpan();
span.CopyTo(buffer.Slice(i, span.Length));
i += span.Length;
}
span = uriParts.path.AsSpan();
span.CopyTo(buffer.Slice(i, span.Length));
i += span.Length;
if (uriParts.query.Length != 0)
{
span = uriParts.query.AsSpan();
span.CopyTo(buffer.Slice(i, span.Length));
}
}));
}
public string StringBuilder_WithoutCombinedPathGeneration(HostString host, PathString pathBase, PathString path, QueryString query, FragmentString fragment)
{
var scheme = "https";
var SchemeDelimiter = Uri.SchemeDelimiter;
var encodedHost = host.ToUriComponent();
var encodedPathBase = pathBase.ToUriComponent();
var encodedPath = path.ToUriComponent();
var encodedQuery = query.ToUriComponent();
var encodedFragment = fragment.ToUriComponent();
// PERF: Calculate string length to allocate correct buffer size for StringBuilder.
var length =
scheme.Length +
SchemeDelimiter.Length +
encodedHost.Length +
encodedPathBase.Length +
encodedPath.Length +
encodedQuery.Length +
encodedFragment.Length;
if (!pathBase.HasValue && !path.HasValue)
{
length++;
}
var builder = new StringBuilder(length)
.Append(scheme)
.Append(SchemeDelimiter)
.Append(encodedHost);
if (!pathBase.HasValue && !path.HasValue)
{
builder.Append('/');
}
else
{
builder
.Append(encodedPathBase)
.Append(encodedPath);
}
return(builder
.Append(encodedQuery)
.Append(encodedFragment)
.ToString());
}
private static Uri BuildUri(StringValues hostHeader, string pathAndQuery)
{
if (hostHeader.Count != 1)
{
throw new InvalidOperationException("Invalid Host Header");
}
var hostString = new HostString(hostHeader.Single());
if (!hostString.HasValue)
{
return(null);
}
var fullUri = $"http://{hostString.ToUriComponent()}{pathAndQuery}";
var uri = new Uri(fullUri);
return(uri);
}
public void VerifyToUriComponent(string input, string expected)
{
HostString host = new HostString(input);
Assert.Equal(expected, host.ToUriComponent(), StringComparer.Ordinal);
}
public void VerifyToUriComponent(string input, string expected)
{
HostString host = new HostString(input);
Assert.Equal(expected, host.ToUriComponent(), StringComparer.Ordinal);
}
public string StringFormatWithoutBoxing(HostString host, PathString basePath, PathString path, QueryString query)
=> $"https://{host.ToUriComponent()}{basePath.ToUriComponent()}{path.ToUriComponent()}{query.ToUriComponent()}";