|
// 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;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text.Encodings.Web;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing.Patterns;
using Microsoft.Extensions.ObjectPool;
namespace Microsoft.AspNetCore.Routing.Template;
/// <summary>
/// Supports processing and binding parameter values in a route template.
/// </summary>
public class TemplateBinder
{
private readonly UrlEncoder _urlEncoder;
private readonly ObjectPool<UriBuildingContext> _pool;
private readonly (string parameterName, IRouteConstraint constraint)[] _constraints;
private readonly RouteValueDictionary? _defaults;
private readonly KeyValuePair<string, object?>[] _filters;
private readonly (string parameterName, IOutboundParameterTransformer transformer)[] _parameterTransformers;
private readonly RoutePattern _pattern;
private readonly string[] _requiredKeys;
// A pre-allocated template for the 'known' route values that this template binder uses.
//
// We always make a copy of this and operate on the copy, so that we don't mutate shared state.
private readonly KeyValuePair<string, object?>[] _slots;
/// <summary>
/// Creates a new instance of <see cref="TemplateBinder"/>.
/// </summary>
/// <param name="urlEncoder">The <see cref="UrlEncoder"/>.</param>
/// <param name="pool">The <see cref="ObjectPool{T}"/>.</param>
/// <param name="template">The <see cref="RouteTemplate"/> to bind values to.</param>
/// <param name="defaults">The default values for <paramref name="template"/>.</param>
internal TemplateBinder(
UrlEncoder urlEncoder,
ObjectPool<UriBuildingContext> pool,
RouteTemplate template,
RouteValueDictionary defaults)
: this(urlEncoder, pool, template?.ToRoutePattern()!, defaults, requiredKeys: null, parameterPolicies: null)
{
}
/// <summary>
/// Creates a new instance of <see cref="TemplateBinder"/>.
/// </summary>
/// <param name="urlEncoder">The <see cref="UrlEncoder"/>.</param>
/// <param name="pool">The <see cref="ObjectPool{T}"/>.</param>
/// <param name="pattern">The <see cref="RoutePattern"/> to bind values to.</param>
/// <param name="defaults">The default values for <paramref name="pattern"/>. Optional.</param>
/// <param name="requiredKeys">Keys used to determine if the ambient values apply. Optional.</param>
/// <param name="parameterPolicies">
/// A list of (<see cref="string"/>, <see cref="IParameterPolicy"/>) pairs to evaluate when producing a URI.
/// </param>
internal TemplateBinder(
UrlEncoder urlEncoder,
ObjectPool<UriBuildingContext> pool,
RoutePattern pattern,
RouteValueDictionary? defaults,
IEnumerable<string>? requiredKeys,
IEnumerable<(string parameterName, IParameterPolicy policy)>? parameterPolicies)
{
ArgumentNullException.ThrowIfNull(urlEncoder);
ArgumentNullException.ThrowIfNull(pool);
ArgumentNullException.ThrowIfNull(pattern);
_urlEncoder = urlEncoder;
_pool = pool;
_pattern = pattern;
_defaults = defaults;
_requiredKeys = requiredKeys?.ToArray() ?? Array.Empty<string>();
// Any default that doesn't have a corresponding parameter is a 'filter' and if a value
// is provided for that 'filter' it must match the value in defaults.
var filters = new RouteValueDictionary(_defaults);
for (var i = 0; i < pattern.Parameters.Count; i++)
{
filters.Remove(pattern.Parameters[i].Name);
}
_filters = filters.ToArray();
Initialize(parameterPolicies, out _constraints, out _parameterTransformers);
_slots = AssignSlots(_pattern, _filters);
}
internal TemplateBinder(
UrlEncoder urlEncoder,
ObjectPool<UriBuildingContext> pool,
RoutePattern pattern,
IEnumerable<(string parameterName, IParameterPolicy policy)> parameterPolicies)
{
ArgumentNullException.ThrowIfNull(urlEncoder);
ArgumentNullException.ThrowIfNull(pool);
ArgumentNullException.ThrowIfNull(pattern);
// Parameter policies can be null.
_urlEncoder = urlEncoder;
_pool = pool;
_pattern = pattern;
_defaults = new RouteValueDictionary(pattern.Defaults);
_requiredKeys = pattern.RequiredValues.Keys.ToArray();
// Any default that doesn't have a corresponding parameter is a 'filter' and if a value
// is provided for that 'filter' it must match the value in defaults.
var filters = new RouteValueDictionary(_defaults);
for (var i = 0; i < pattern.Parameters.Count; i++)
{
filters.Remove(pattern.Parameters[i].Name);
}
_filters = filters.ToArray();
Initialize(parameterPolicies, out _constraints, out _parameterTransformers);
_slots = AssignSlots(_pattern, _filters);
}
private static void Initialize(
IEnumerable<(string parameterName, IParameterPolicy policy)>? parameterPolicies,
out (string parameterName, IRouteConstraint constraint)[] constraints,
out (string parameterName, IOutboundParameterTransformer transformer)[] parameterTransformers)
{
List<(string parameterName, IRouteConstraint constraint)>? constraintList = null;
List<(string parameterName, IOutboundParameterTransformer transformer)>? parameterTransformerList = null;
if (parameterPolicies is not null)
{
foreach (var p in parameterPolicies)
{
if (p.policy is IRouteConstraint routeConstraint)
{
(constraintList ??= new()).Add((p.parameterName, routeConstraint));
}
if (p.policy is IOutboundParameterTransformer transformer)
{
(parameterTransformerList ??= new()).Add((p.parameterName, transformer));
}
}
}
constraints = constraintList?.ToArray() ?? Array.Empty<(string, IRouteConstraint)>();
parameterTransformers = parameterTransformerList?.ToArray() ?? Array.Empty<(string, IOutboundParameterTransformer)>();
}
/// <summary>
/// Generates the parameter values in the route.
/// </summary>
/// <param name="ambientValues">The values associated with the current request.</param>
/// <param name="values">The route values to process.</param>
/// <returns>A <see cref="TemplateValuesResult"/> instance. Can be null.</returns>
public TemplateValuesResult? GetValues(RouteValueDictionary? ambientValues, RouteValueDictionary values)
{
// Make a new copy of the slots array, we'll use this as 'scratch' space
// and then the RVD will take ownership of it.
var slots = new KeyValuePair<string, object?>[_slots.Length];
Array.Copy(_slots, 0, slots, 0, slots.Length);
// Keeping track of the number of 'values' we've processed can be used to avoid doing
// some expensive 'merge' operations later.
var valueProcessedCount = 0;
// Start by copying all of the values out of the 'values' and into the slots. There's no success
// case where we *don't* use all of the 'values' so there's no reason not to do this up front
// to avoid visiting the values dictionary again and again.
for (var i = 0; i < slots.Length; i++)
{
var key = slots[i].Key;
if (values.TryGetValue(key, out var value))
{
// We will need to know later if the value in the 'values' was an null value.
// This affects how we process ambient values. Since the 'slots' are initialized
// with null values, we use the null-object-pattern to track 'explicit null', which means that
// null means omitted.
value = IsRoutePartNonEmpty(value) ? value : SentinullValue.Instance;
slots[i] = new KeyValuePair<string, object?>(key, value);
// Track the count of processed values - this allows a fast path later.
valueProcessedCount++;
}
}
// In Endpoint Routing, patterns can have logical parameters that appear 'to the left' of
// the route template. This governs whether or not the template can be selected (they act like
// filters), and whether the remaining ambient values should be used.
// should be used.
// For example, in case of MVC it flattens out a route template like below
// {controller}/{action}/{id?}
// to
// Products/Index/{id?},
// defaults: new { controller = "Products", action = "Index" },
// requiredValues: new { controller = "Products", action = "Index" }
// In the above example, "controller" and "action" are no longer parameters.
var copyAmbientValues = ambientValues != null;
if (copyAmbientValues)
{
var requiredKeys = _requiredKeys;
for (var i = 0; i < requiredKeys.Length; i++)
{
// For each required key, the values and ambient values need to have the same value.
var key = requiredKeys[i];
var hasExplicitValue = values.TryGetValue(key, out var value);
if (ambientValues == null || !ambientValues.TryGetValue(key, out var ambientValue))
{
ambientValue = null;
}
// For now, only check ambient values with required values that don't have a parameter
// Ambient values for parameters are processed below
var hasParameter = _pattern.GetParameter(key) != null;
if (!hasParameter)
{
if (!_pattern.RequiredValues.TryGetValue(key, out var requiredValue))
{
throw new InvalidOperationException($"Unable to find required value '{key}' on route pattern.");
}
if (!RoutePartsEqual(ambientValue, _pattern.RequiredValues[key]) &&
!RoutePattern.IsRequiredValueAny(_pattern.RequiredValues[key]))
{
copyAmbientValues = false;
break;
}
if (hasExplicitValue && !RoutePartsEqual(value, ambientValue))
{
copyAmbientValues = false;
break;
}
}
}
}
// We can now process the rest of the parameters (from left to right) and copy the ambient
// values as long as the conditions are met.
//
// Find out which entries in the URI are valid for the URI we want to generate.
// If the URI had ordered parameters a="1", b="2", c="3" and the new values
// specified that b="9", then we need to invalidate everything after it. The new
// values should then be a="1", b="9", c=<no value>.
//
// We also handle the case where a parameter is optional but has no value - we shouldn't
// accept additional parameters that appear *after* that parameter.
var parameters = _pattern.Parameters;
var parameterCount = _pattern.Parameters.Count;
for (var i = 0; i < parameterCount; i++)
{
var key = slots[i].Key;
var value = slots[i].Value;
// Whether or not the value was explicitly provided is signficant when comparing
// ambient values. Remember that we're using a special sentinel value so that we
// can tell the difference between an omitted value and an explicitly specified null.
var hasExplicitValue = value != null;
var hasAmbientValue = false;
var ambientValue = (object?)null;
var parameter = parameters[i];
// We are copying **all** ambient values
if (copyAmbientValues)
{
hasAmbientValue = ambientValues != null && ambientValues.TryGetValue(key, out ambientValue);
if (hasExplicitValue && hasAmbientValue && !RoutePartsEqual(ambientValue, value))
{
// Stop copying current values when we find one that doesn't match
copyAmbientValues = false;
}
if (!hasExplicitValue &&
!hasAmbientValue &&
_defaults?.ContainsKey(parameter.Name) != true)
{
// This is an unsatisfied parameter value and there are no defaults. We might still
// be able to generate a URL but we should stop 'accepting' ambient values.
//
// This might be a case like:
// template: a/{b?}/{c?}
// ambient: { c = 17 }
// values: { }
//
// We can still generate a URL from this ("/a") but we shouldn't accept 'c' because
// we can't use it.
//
// In the example above we should fall into this block for 'b'.
copyAmbientValues = false;
}
}
// This might be an ambient value that matches a required value. We want to use these even if we're
// not bulk-copying ambient values.
//
// This comes up in a case like the following:
// ambient-values: { page = "/DeleteUser", area = "Admin", }
// values: { controller = "Home", action = "Index", }
// pattern: {area}/{controller}/{action}/{id?}
// required-values: { area = "Admin", controller = "Home", action = "Index", page = (string)null, }
//
// OR in plain English... when linking from a page in an area to an action in the same area, it should
// be possible to use the area as an ambient value.
if (!copyAmbientValues && !hasExplicitValue && _pattern.RequiredValues.TryGetValue(key, out var requiredValue))
{
hasAmbientValue = ambientValues != null && ambientValues.TryGetValue(key, out ambientValue);
if (hasAmbientValue &&
(RoutePartsEqual(requiredValue, ambientValue) || RoutePattern.IsRequiredValueAny(requiredValue)))
{
// Treat this an an explicit value to *force it*.
slots[i] = new KeyValuePair<string, object?>(key, ambientValue);
hasExplicitValue = true;
value = ambientValue;
}
}
// If the parameter is a match, add it to the list of values we will use for URI generation
if (hasExplicitValue && !ReferenceEquals(value, SentinullValue.Instance))
{
// Already has a value in the list, do nothing
}
else if (copyAmbientValues && hasAmbientValue)
{
slots[i] = new KeyValuePair<string, object?>(key, ambientValue);
}
else if (parameter.IsOptional || parameter.IsCatchAll)
{
// Value isn't needed for optional or catchall parameters - wipe out the key, so it
// will be omitted from the RVD.
slots[i] = default;
}
else if (_defaults != null && _defaults.TryGetValue(parameter.Name, out var defaultValue))
{
// Add the default value only if there isn't already a new value for it and
// only if it actually has a default value.
slots[i] = new KeyValuePair<string, object?>(key, defaultValue);
}
else
{
// If we get here, this parameter needs a value, but doesn't have one. This is a
// failure case.
return null;
}
}
// Any default values that don't appear as parameters are treated like filters. Any new values
// provided must match these defaults.
var filters = _filters;
for (var i = 0; i < filters.Length; i++)
{
var key = filters[i].Key;
var value = slots[i + parameterCount].Value;
// We use a sentinel value here so we can track the different between omission and explicit null.
// 'real null' means that the value was omitted.
var hasExplictValue = value != null;
if (hasExplictValue)
{
// If there is a non-parameterized value in the route and there is a
// new value for it and it doesn't match, this route won't match.
if (!RoutePartsEqual(value, filters[i].Value))
{
return null;
}
}
else
{
// If no value was provided, then blank out this slot so that it doesn't show up in accepted values.
slots[i + parameterCount] = default;
}
}
// At this point we've captured all of the 'known' route values, but we have't
// handled an extra route values that were provided in 'values'. These all
// need to be included in the accepted values.
var acceptedValues = RouteValueDictionary.FromArray(slots);
if (valueProcessedCount < values.Count)
{
// There are some values in 'value' that are unaccounted for, merge them into
// the dictionary.
foreach (var kvp in values)
{
if (!_defaults!.ContainsKey(kvp.Key))
{
#if RVD_TryAdd
acceptedValues.TryAdd(kvp.Key, kvp.Value);
#else
if (!acceptedValues.ContainsKey(kvp.Key))
{
acceptedValues.Add(kvp.Key, kvp.Value);
}
#endif
}
}
}
// Currently this copy is required because BindValues will mutate the accepted values :(
var combinedValues = new RouteValueDictionary(acceptedValues);
// Add any ambient values that don't match parameters - they need to be visible to constraints
// but they will ignored by link generation.
CopyNonParameterAmbientValues(
ambientValues: ambientValues,
acceptedValues: acceptedValues,
combinedValues: combinedValues);
return new TemplateValuesResult()
{
AcceptedValues = acceptedValues,
CombinedValues = combinedValues,
};
}
// Step 1.5: Process constraints
/// <summary>
/// Processes the constraints **if** they were passed in to the TemplateBinder constructor.
/// </summary>
/// <param name="httpContext">The <see cref="HttpContext"/> associated with the current request.</param>
/// <param name="combinedValues">A dictionary that contains the parameters for the route.</param>
/// <param name="parameterName">The name of the parameter.</param>
/// <param name="constraint">The constraint object.</param>
/// <returns><see langword="true"/> if constraints were processed succesfully and false otherwise.</returns>
public bool TryProcessConstraints(HttpContext? httpContext, RouteValueDictionary combinedValues, out string? parameterName, out IRouteConstraint? constraint)
{
var constraints = _constraints;
for (var i = 0; i < constraints.Length; i++)
{
(parameterName, constraint) = constraints[i];
if (!constraint.Match(httpContext, NullRouter.Instance, parameterName, combinedValues, RouteDirection.UrlGeneration))
{
return false;
}
}
parameterName = null;
constraint = null;
return true;
}
// Step 2: If the route is a match generate the appropriate URI
/// <summary>
/// Returns a string representation of the URI associated with the route.
/// </summary>
/// <param name="acceptedValues">A dictionary that contains the parameters for the route.</param>
/// <returns>The string representation of the route.</returns>
public string? BindValues(RouteValueDictionary acceptedValues)
{
var context = _pool.Get();
try
{
return TryBindValuesCore(context, acceptedValues) ? context.ToString() : null;
}
finally
{
_pool.Return(context);
}
}
// Step 2: If the route is a match generate the appropriate URI
internal bool TryBindValues(
RouteValueDictionary acceptedValues,
LinkOptions? options,
LinkOptions globalOptions,
out (PathString path, QueryString query) result)
{
var context = _pool.Get();
context.AppendTrailingSlash = options?.AppendTrailingSlash ?? globalOptions.AppendTrailingSlash ?? false;
context.LowercaseQueryStrings = options?.LowercaseQueryStrings ?? globalOptions.LowercaseQueryStrings ?? false;
context.LowercaseUrls = options?.LowercaseUrls ?? globalOptions.LowercaseUrls ?? false;
try
{
if (TryBindValuesCore(context, acceptedValues))
{
result = (context.ToPathString(), context.ToQueryString());
return true;
}
result = default;
return false;
}
finally
{
_pool.Return(context);
}
}
private bool TryBindValuesCore(UriBuildingContext context, RouteValueDictionary acceptedValues)
{
// If we have any output parameter transformers, allow them a chance to influence the parameter values
// before we build the URI.
var parameterTransformers = _parameterTransformers;
for (var i = 0; i < parameterTransformers.Length; i++)
{
(var parameterName, var transformer) = parameterTransformers[i];
if (acceptedValues.TryGetValue(parameterName, out var value))
{
acceptedValues[parameterName] = transformer.TransformOutbound(value);
}
}
var segments = _pattern.PathSegments;
// Read interface .Count once rather than per iteration
var segmentsCount = segments.Count;
for (var i = 0; i < segmentsCount; i++)
{
Debug.Assert(context.BufferState == SegmentState.Beginning);
Debug.Assert(context.UriState == SegmentState.Beginning);
var parts = segments[i].Parts;
// Read interface .Count once rather than per iteration
var partsCount = parts.Count;
for (var j = 0; j < partsCount; j++)
{
var part = parts[j];
if (part is RoutePatternLiteralPart literalPart)
{
if (!context.Accept(literalPart.Content))
{
return false;
}
}
else if (part is RoutePatternSeparatorPart separatorPart)
{
if (!context.Accept(separatorPart.Content))
{
return false;
}
}
else if (part is RoutePatternParameterPart parameterPart)
{
// If it's a parameter, get its value
acceptedValues.Remove(parameterPart.Name, out var value);
var isSameAsDefault = false;
if (_defaults != null &&
_defaults.TryGetValue(parameterPart.Name, out var defaultValue) &&
RoutePartsEqual(value, defaultValue))
{
isSameAsDefault = true;
}
var converted = Convert.ToString(value, CultureInfo.InvariantCulture);
if (isSameAsDefault)
{
// If the accepted value is the same as the default value buffer it since
// we won't necessarily add it to the URI we generate.
if (!context.Buffer(converted))
{
return false;
}
}
else
{
// If the value is not accepted, it is null or empty value in the
// middle of the segment. We accept this if the parameter is an
// optional parameter and it is preceded by an optional seperator.
// In this case, we need to remove the optional seperator that we
// have added to the URI
// Example: template = {id}.{format?}. parameters: id=5
// In this case after we have generated "5.", we wont find any value
// for format, so we remove '.' and generate 5.
if (!context.Accept(converted, parameterPart.EncodeSlashes))
{
if (j != 0 && parameterPart.IsOptional && parts[j - 1] is RoutePatternSeparatorPart)
{
context.Remove();
}
else
{
return false;
}
}
}
}
}
context.EndSegment();
}
// Generate the query string from the remaining values
var wroteFirst = false;
foreach (var kvp in acceptedValues)
{
if (_defaults != null && _defaults.ContainsKey(kvp.Key))
{
// This value is a 'filter' we don't need to put it in the query string.
continue;
}
var values = kvp.Value as IEnumerable;
if (values != null && !(values is string))
{
foreach (var value in values)
{
wroteFirst |= AddQueryKeyValueToContext(context, kvp.Key, value, wroteFirst);
}
}
else
{
wroteFirst |= AddQueryKeyValueToContext(context, kvp.Key, kvp.Value, wroteFirst);
}
}
return true;
}
private bool AddQueryKeyValueToContext(UriBuildingContext context, string key, object? value, bool wroteFirst)
{
var converted = Convert.ToString(value, CultureInfo.InvariantCulture);
if (!string.IsNullOrEmpty(converted))
{
if (context.LowercaseQueryStrings)
{
key = key.ToLowerInvariant();
converted = converted.ToLowerInvariant();
}
context.QueryWriter.Write(wroteFirst ? '&' : '?');
_urlEncoder.Encode(context.QueryWriter, key);
context.QueryWriter.Write('=');
_urlEncoder.Encode(context.QueryWriter, converted);
return true;
}
return false;
}
/// <summary>
/// Compares two objects for equality as parts of a case-insensitive path.
/// </summary>
/// <param name="a">An object to compare.</param>
/// <param name="b">An object to compare.</param>
/// <returns>True if the object are equal, otherwise false.</returns>
public static bool RoutePartsEqual(object? a, object? b)
{
var sa = a as string ?? (ReferenceEquals(SentinullValue.Instance, a) ? string.Empty : null);
var sb = b as string ?? (ReferenceEquals(SentinullValue.Instance, b) ? string.Empty : null);
// In case of strings, consider empty and null the same.
// Since null cannot tell us the type, consider it to be a string if the other value is a string.
if ((sa == string.Empty && sb == null) || (sb == string.Empty && sa == null))
{
return true;
}
else if (sa != null && sb != null)
{
// For strings do a case-insensitive comparison
return string.Equals(sa, sb, StringComparison.OrdinalIgnoreCase);
}
else
{
if (a != null && b != null)
{
// Explicitly call .Equals() in case it is overridden in the type
return a.Equals(b);
}
else
{
// At least one of them is null. Return true if they both are
return a == b;
}
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static bool IsRoutePartNonEmpty(object? part)
{
if (part == null)
{
return false;
}
if (ReferenceEquals(SentinullValue.Instance, part))
{
return false;
}
if (part is string stringPart && stringPart.Length == 0)
{
return false;
}
return true;
}
private void CopyNonParameterAmbientValues(
RouteValueDictionary? ambientValues,
RouteValueDictionary acceptedValues,
RouteValueDictionary combinedValues)
{
if (ambientValues == null)
{
return;
}
foreach (var kvp in ambientValues)
{
if (IsRoutePartNonEmpty(kvp.Value))
{
var parameter = _pattern.GetParameter(kvp.Key);
if (parameter == null && !acceptedValues.ContainsKey(kvp.Key))
{
combinedValues.Add(kvp.Key, kvp.Value);
}
}
}
}
private static KeyValuePair<string, object?>[] AssignSlots(RoutePattern pattern, KeyValuePair<string, object?>[] filters)
{
var slots = new KeyValuePair<string, object?>[pattern.Parameters.Count + filters.Length];
for (var i = 0; i < pattern.Parameters.Count; i++)
{
slots[i] = new KeyValuePair<string, object?>(pattern.Parameters[i].Name, null);
}
for (var i = 0; i < filters.Length; i++)
{
slots[i + pattern.Parameters.Count] = new KeyValuePair<string, object?>(filters[i].Key, null);
}
return slots;
}
// This represents an 'explicit null' in the slots array.
[DebuggerDisplay("explicit null")]
private sealed class SentinullValue
{
public static object Instance = new SentinullValue();
private SentinullValue()
{
}
public override string ToString() => string.Empty;
}
}
|