660 lines
28 KiB
C#
660 lines
28 KiB
C#
// 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 System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
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.Internal;
|
|
using Microsoft.AspNetCore.Routing.Patterns;
|
|
using Microsoft.Extensions.ObjectPool;
|
|
|
|
namespace Microsoft.AspNetCore.Routing.Template
|
|
{
|
|
public class TemplateBinder
|
|
{
|
|
private readonly UrlEncoder _urlEncoder;
|
|
private readonly ObjectPool<UriBuildingContext> _pool;
|
|
private readonly ParameterPolicyFactory _parameterPolicyFactory;
|
|
|
|
private readonly RouteValueDictionary _defaults;
|
|
private readonly KeyValuePair<string, object>[] _filters;
|
|
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>
|
|
public TemplateBinder(
|
|
UrlEncoder urlEncoder,
|
|
ObjectPool<UriBuildingContext> pool,
|
|
RouteTemplate template,
|
|
RouteValueDictionary defaults)
|
|
: this(urlEncoder, pool, template?.ToRoutePattern(), defaults, requiredKeys: null, parameterPolicyFactory: 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="parameterPolicyFactory">The <see cref="ParameterPolicyFactory"/>.</param>
|
|
public TemplateBinder(
|
|
UrlEncoder urlEncoder,
|
|
ObjectPool<UriBuildingContext> pool,
|
|
RoutePattern pattern,
|
|
RouteValueDictionary defaults,
|
|
IEnumerable<string> requiredKeys,
|
|
ParameterPolicyFactory parameterPolicyFactory)
|
|
{
|
|
if (urlEncoder == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(urlEncoder));
|
|
}
|
|
|
|
if (pool == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(pool));
|
|
}
|
|
|
|
if (pattern == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(pattern));
|
|
}
|
|
|
|
_urlEncoder = urlEncoder;
|
|
_pool = pool;
|
|
_pattern = pattern;
|
|
_defaults = defaults;
|
|
_parameterPolicyFactory = parameterPolicyFactory;
|
|
_requiredKeys = requiredKeys?.ToArray() ?? Array.Empty<string>();
|
|
|
|
for (var i = 0; i < _requiredKeys.Length; i++)
|
|
{
|
|
var requiredKey = _requiredKeys[i];
|
|
if (_pattern.GetParameter(requiredKey) != null)
|
|
{
|
|
throw new InvalidOperationException(
|
|
$"The parameter {requiredKey} can not be used as a required key since it appears as " +
|
|
$"a parameter in the route pattern.");
|
|
}
|
|
}
|
|
|
|
// 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);
|
|
foreach (var parameter in _pattern.Parameters)
|
|
{
|
|
filters.Remove(parameter.Name);
|
|
}
|
|
|
|
_filters = filters.ToArray();
|
|
|
|
_slots = AssignSlots(_pattern, _filters);
|
|
}
|
|
|
|
// Step 1: Get the list of values we're going to try to use to match and generate this URI
|
|
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' and 'ambient values' we've processed can be used to avoid doing
|
|
// some expensive 'merge' operations later.
|
|
var valueProcessedCount = 0;
|
|
var ambientValueProcessedCount = 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;
|
|
}
|
|
else
|
|
{
|
|
// Track the count of processed ambient values - this allows a fast path later.
|
|
ambientValueProcessedCount++;
|
|
}
|
|
|
|
if (hasExplicitValue)
|
|
{
|
|
// Note that we don't increment valueProcessedCount here. We expect required values
|
|
// to also be filters, which are tracked when we populate 'slots'.
|
|
if (!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];
|
|
|
|
if (copyAmbientValues)
|
|
{
|
|
hasAmbientValue = ambientValues != null && ambientValues.TryGetValue(key, out ambientValue);
|
|
if (hasAmbientValue)
|
|
{
|
|
// Track the count of processed ambient values - this allows a fast path later.
|
|
ambientValueProcessedCount++;
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
// 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);
|
|
if (ambientValueProcessedCount < (ambientValues?.Count ?? 0))
|
|
{
|
|
// 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 2: If the route is a match generate the appropriate URI
|
|
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)
|
|
{
|
|
for (var i = 0; i < _pattern.PathSegments.Count; i++)
|
|
{
|
|
Debug.Assert(context.BufferState == SegmentState.Beginning);
|
|
Debug.Assert(context.UriState == SegmentState.Beginning);
|
|
|
|
var segment = _pattern.PathSegments[i];
|
|
|
|
for (var j = 0; j < segment.Parts.Count; j++)
|
|
{
|
|
var part = segment.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
|
|
var hasValue = acceptedValues.TryGetValue(parameterPart.Name, out var value);
|
|
if (hasValue)
|
|
{
|
|
acceptedValues.Remove(parameterPart.Name);
|
|
}
|
|
|
|
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, GetParameterTransformer(parameterPart)))
|
|
{
|
|
if (j != 0 && parameterPart.IsOptional && (separatorPart = segment.Parts[j - 1] as RoutePatternSeparatorPart) != null)
|
|
{
|
|
context.Remove(separatorPart.Content);
|
|
}
|
|
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 IParameterTransformer GetParameterTransformer(RoutePatternParameterPart parameterPart)
|
|
{
|
|
if (_parameterPolicyFactory == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
for (var i = 0; i < parameterPart.ParameterPolicies.Count; i++)
|
|
{
|
|
// Use the first parameter transformer
|
|
var parameterPolicy = _parameterPolicyFactory.Create(parameterPart, parameterPart.ParameterPolicies[i]);
|
|
if (parameterPolicy is IParameterTransformer parameterTransformer)
|
|
{
|
|
return parameterTransformer;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
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 class SentinullValue
|
|
{
|
|
public static object Instance = new SentinullValue();
|
|
|
|
private SentinullValue()
|
|
{
|
|
}
|
|
|
|
public override string ToString() => string.Empty;
|
|
}
|
|
}
|
|
}
|