private static bool ForEachParameter(IList <PathSegment> pathSegments, Func <ParameterSubsegment, bool> action)
 {
     for (int i = 0; i < pathSegments.Count; i++)
     {
         PathSegment segment = pathSegments[i];
         if (!(segment is SeparatorPathSegment))
         {
             ContentPathSegment segment2 = segment as ContentPathSegment;
             if (segment2 != null)
             {
                 foreach (PathSubsegment subsegment in segment2.Subsegments)
                 {
                     if (!(subsegment is LiteralSubsegment))
                     {
                         ParameterSubsegment arg = subsegment as ParameterSubsegment;
                         if ((arg != null) && !action(arg))
                         {
                             return(false);
                         }
                     }
                 }
             }
         }
     }
     return(true);
 }
 private static bool IsParameterRequired(ParameterSubsegment parameterSubsegment, RouteValueDictionary defaultValues, out object defaultValue)
 {
     if (parameterSubsegment.IsCatchAll)
     {
         defaultValue = null;
         return(false);
     }
     return(!defaultValues.TryGetValue(parameterSubsegment.ParameterName, out defaultValue));
 }
        private static ParameterSubsegment GetParameterSubsegment(IList <PathSegment> pathSegments, string parameterName)
        {
            ParameterSubsegment foundParameterSubsegment = null;

            ForEachParameter(pathSegments, delegate(ParameterSubsegment parameterSubsegment) {
                if (string.Equals(parameterName, parameterSubsegment.ParameterName, StringComparison.OrdinalIgnoreCase))
                {
                    foundParameterSubsegment = parameterSubsegment;
                    return(false);
                }
                return(true);
            });
            return(foundParameterSubsegment);
        }
        private static bool ForEachParameter(IList <PathSegment> pathSegments, Func <ParameterSubsegment, bool> action)
        {
            for (int i = 0; i < pathSegments.Count; i++)
            {
                PathSegment pathSegment = pathSegments[i];

                if (pathSegment is SeparatorPathSegment)
                {
                    // We only care about parameter subsegments, so skip this
                    continue;
                }
                else
                {
                    ContentPathSegment contentPathSegment = pathSegment as ContentPathSegment;
                    if (contentPathSegment != null)
                    {
                        foreach (PathSubsegment subsegment in contentPathSegment.Subsegments)
                        {
                            LiteralSubsegment literalSubsegment = subsegment as LiteralSubsegment;
                            if (literalSubsegment != null)
                            {
                                // We only care about parameter subsegments, so skip this
                                continue;
                            }
                            else
                            {
                                ParameterSubsegment parameterSubsegment = subsegment as ParameterSubsegment;
                                if (parameterSubsegment != null)
                                {
                                    if (!action(parameterSubsegment))
                                    {
                                        return(false);
                                    }
                                }
                                else
                                {
                                    Debug.Fail("Invalid path subsegment type");
                                }
                            }
                        }
                    }
                    else
                    {
                        Debug.Fail("Invalid path segment type");
                    }
                }
            }

            return(true);
        }
        private void MatchCatchAll(ContentPathSegment contentPathSegment, IEnumerable <string> remainingRequestSegments, RouteValueDictionary defaultValues, RouteValueDictionary matchedValues)
        {
            object obj2;
            string str = string.Join(string.Empty, remainingRequestSegments.ToArray <string>());
            ParameterSubsegment subsegment = contentPathSegment.Subsegments[0] as ParameterSubsegment;

            if (str.Length > 0)
            {
                obj2 = str;
            }
            else
            {
                defaultValues.TryGetValue(subsegment.ParameterName, out obj2);
            }
            matchedValues.Add(subsegment.ParameterName, obj2);
        }
        private void MatchCatchAll(ContentPathSegment contentPathSegment, IEnumerable <string> remainingRequestSegments, RouteValueDictionary defaultValues, RouteValueDictionary matchedValues)
        {
            string remainingRequest = String.Join(String.Empty, remainingRequestSegments.ToArray());

            ParameterSubsegment catchAllSegment = contentPathSegment.Subsegments[0] as ParameterSubsegment;

            object catchAllValue;

            if (remainingRequest.Length > 0)
            {
                catchAllValue = remainingRequest;
            }
            else
            {
                defaultValues.TryGetValue(catchAllSegment.ParameterName, out catchAllValue);
            }
            matchedValues.Add(catchAllSegment.ParameterName, catchAllValue);
        }
Beispiel #7
0
        private static Exception ValidateUrlSegment(IList <PathSubsegment> pathSubsegments, HashSet <string> usedParameterNames, string pathSegment)
        {
            bool flag = false;
            Type type = null;

            foreach (PathSubsegment subsegment in pathSubsegments)
            {
                if ((type != null) && (type == subsegment.GetType()))
                {
                    return(new ArgumentException(string.Format(CultureInfo.CurrentUICulture, System.Web.SR.GetString("Route_CannotHaveConsecutiveParameters"), new object[0]), "routeUrl"));
                }
                type = subsegment.GetType();
                if (!(subsegment is LiteralSubsegment))
                {
                    ParameterSubsegment subsegment3 = subsegment as ParameterSubsegment;
                    if (subsegment3 != null)
                    {
                        string parameterName = subsegment3.ParameterName;
                        if (subsegment3.IsCatchAll)
                        {
                            flag = true;
                        }
                        if (!IsValidParameterName(parameterName))
                        {
                            return(new ArgumentException(string.Format(CultureInfo.CurrentUICulture, System.Web.SR.GetString("Route_InvalidParameterName"), new object[] { parameterName }), "routeUrl"));
                        }
                        if (usedParameterNames.Contains(parameterName))
                        {
                            return(new ArgumentException(string.Format(CultureInfo.CurrentUICulture, System.Web.SR.GetString("Route_RepeatedParameter"), new object[] { parameterName }), "routeUrl"));
                        }
                        usedParameterNames.Add(parameterName);
                    }
                }
            }
            if (flag && (pathSubsegments.Count != 1))
            {
                return(new ArgumentException(string.Format(CultureInfo.CurrentUICulture, System.Web.SR.GetString("Route_CannotHaveCatchAllInMultiSegment"), new object[0]), "routeUrl"));
            }
            return(null);
        }
        private static bool IsParameterRequired(ParameterSubsegment parameterSubsegment, RouteValueDictionary defaultValues, out object defaultValue) {
            if (parameterSubsegment.IsCatchAll) {
                defaultValue = null;
                return false;
            }

            return !defaultValues.TryGetValue(parameterSubsegment.ParameterName, out defaultValue);
        }
        private bool MatchContentPathSegment(ContentPathSegment routeSegment, string requestPathSegment, RouteValueDictionary defaultValues, RouteValueDictionary matchedValues)
        {
            if (string.IsNullOrEmpty(requestPathSegment))
            {
                if (routeSegment.Subsegments.Count <= 1)
                {
                    object obj2;
                    ParameterSubsegment subsegment = routeSegment.Subsegments[0] as ParameterSubsegment;
                    if (subsegment == null)
                    {
                        return(false);
                    }
                    if (defaultValues.TryGetValue(subsegment.ParameterName, out obj2))
                    {
                        matchedValues.Add(subsegment.ParameterName, obj2);
                        return(true);
                    }
                }
                return(false);
            }
            int length = requestPathSegment.Length;
            int num2   = routeSegment.Subsegments.Count - 1;
            ParameterSubsegment subsegment2 = null;
            LiteralSubsegment   subsegment3 = null;

            while (num2 >= 0)
            {
                int num3 = length;
                ParameterSubsegment subsegment4 = routeSegment.Subsegments[num2] as ParameterSubsegment;
                if (subsegment4 != null)
                {
                    subsegment2 = subsegment4;
                }
                else
                {
                    LiteralSubsegment subsegment5 = routeSegment.Subsegments[num2] as LiteralSubsegment;
                    if (subsegment5 != null)
                    {
                        subsegment3 = subsegment5;
                        int startIndex = length - 1;
                        if (subsegment2 != null)
                        {
                            startIndex--;
                        }
                        if (startIndex < 0)
                        {
                            return(false);
                        }
                        int num5 = requestPathSegment.LastIndexOf(subsegment5.Literal, startIndex, StringComparison.OrdinalIgnoreCase);
                        if (num5 == -1)
                        {
                            return(false);
                        }
                        if ((num2 == (routeSegment.Subsegments.Count - 1)) && ((num5 + subsegment5.Literal.Length) != requestPathSegment.Length))
                        {
                            return(false);
                        }
                        num3 = num5;
                    }
                }
                if ((subsegment2 != null) && (((subsegment3 != null) && (subsegment4 == null)) || (num2 == 0)))
                {
                    int num6;
                    int num7;
                    if (subsegment3 == null)
                    {
                        if (num2 == 0)
                        {
                            num6 = 0;
                        }
                        else
                        {
                            num6 = num3 + subsegment3.Literal.Length;
                        }
                        num7 = length;
                    }
                    else if ((num2 == 0) && (subsegment4 != null))
                    {
                        num6 = 0;
                        num7 = length;
                    }
                    else
                    {
                        num6 = num3 + subsegment3.Literal.Length;
                        num7 = length - num6;
                    }
                    string str = requestPathSegment.Substring(num6, num7);
                    if (string.IsNullOrEmpty(str))
                    {
                        return(false);
                    }
                    matchedValues.Add(subsegment2.ParameterName, str);
                    subsegment2 = null;
                    subsegment3 = null;
                }
                length = num3;
                num2--;
            }
            if (length != 0)
            {
                return(routeSegment.Subsegments[0] is ParameterSubsegment);
            }
            return(true);
        }
        public BoundUrl Bind(RouteValueDictionary currentValues, RouteValueDictionary values, RouteValueDictionary defaultValues, RouteValueDictionary constraints)
        {
            if (currentValues == null)
            {
                currentValues = new RouteValueDictionary();
            }
            if (values == null)
            {
                values = new RouteValueDictionary();
            }
            if (defaultValues == null)
            {
                defaultValues = new RouteValueDictionary();
            }
            RouteValueDictionary acceptedValues  = new RouteValueDictionary();
            HashSet <string>     unusedNewValues = new HashSet <string>(values.Keys, StringComparer.OrdinalIgnoreCase);

            ForEachParameter(this.PathSegments, delegate(ParameterSubsegment parameterSubsegment) {
                object obj2;
                object obj3;
                string key = parameterSubsegment.ParameterName;
                bool flag  = values.TryGetValue(key, out obj2);
                if (flag)
                {
                    unusedNewValues.Remove(key);
                }
                bool flag2 = currentValues.TryGetValue(key, out obj3);
                if ((flag && flag2) && !RoutePartsEqual(obj3, obj2))
                {
                    return(false);
                }
                if (flag)
                {
                    if (IsRoutePartNonEmpty(obj2))
                    {
                        acceptedValues.Add(key, obj2);
                    }
                }
                else if (flag2)
                {
                    acceptedValues.Add(key, obj3);
                }
                return(true);
            });
            foreach (KeyValuePair <string, object> pair in values)
            {
                if (IsRoutePartNonEmpty(pair.Value) && !acceptedValues.ContainsKey(pair.Key))
                {
                    acceptedValues.Add(pair.Key, pair.Value);
                }
            }
            foreach (KeyValuePair <string, object> pair2 in currentValues)
            {
                string str = pair2.Key;
                if (!acceptedValues.ContainsKey(str) && (GetParameterSubsegment(this.PathSegments, str) == null))
                {
                    acceptedValues.Add(str, pair2.Value);
                }
            }
            ForEachParameter(this.PathSegments, delegate(ParameterSubsegment parameterSubsegment) {
                object obj2;
                if (!acceptedValues.ContainsKey(parameterSubsegment.ParameterName) && !IsParameterRequired(parameterSubsegment, defaultValues, out obj2))
                {
                    acceptedValues.Add(parameterSubsegment.ParameterName, obj2);
                }
                return(true);
            });
            if (!ForEachParameter(this.PathSegments, delegate(ParameterSubsegment parameterSubsegment) {
                object obj2;
                if (IsParameterRequired(parameterSubsegment, defaultValues, out obj2) && !acceptedValues.ContainsKey(parameterSubsegment.ParameterName))
                {
                    return(false);
                }
                return(true);
            }))
            {
                return(null);
            }
            RouteValueDictionary otherDefaultValues = new RouteValueDictionary(defaultValues);

            ForEachParameter(this.PathSegments, delegate(ParameterSubsegment parameterSubsegment) {
                otherDefaultValues.Remove(parameterSubsegment.ParameterName);
                return(true);
            });
            foreach (KeyValuePair <string, object> pair3 in otherDefaultValues)
            {
                object obj2;
                if (values.TryGetValue(pair3.Key, out obj2))
                {
                    unusedNewValues.Remove(pair3.Key);
                    if (!RoutePartsEqual(obj2, pair3.Value))
                    {
                        return(null);
                    }
                }
            }
            StringBuilder builder  = new StringBuilder();
            StringBuilder builder2 = new StringBuilder();
            bool          flag2    = false;

            for (int i = 0; i < this.PathSegments.Count; i++)
            {
                PathSegment segment = this.PathSegments[i];
                if (segment is SeparatorPathSegment)
                {
                    if (flag2 && (builder2.Length > 0))
                    {
                        builder.Append(builder2.ToString());
                        builder2.Length = 0;
                    }
                    flag2 = false;
                    if ((builder2.Length > 0) && (builder2[builder2.Length - 1] == '/'))
                    {
                        return(null);
                    }
                    builder2.Append("/");
                }
                else
                {
                    ContentPathSegment segment2 = segment as ContentPathSegment;
                    if (segment2 != null)
                    {
                        bool flag3 = false;
                        foreach (PathSubsegment subsegment2 in segment2.Subsegments)
                        {
                            LiteralSubsegment subsegment3 = subsegment2 as LiteralSubsegment;
                            if (subsegment3 != null)
                            {
                                flag2 = true;
                                builder2.Append(UrlEncode(subsegment3.Literal));
                            }
                            else
                            {
                                ParameterSubsegment subsegment4 = subsegment2 as ParameterSubsegment;
                                if (subsegment4 != null)
                                {
                                    object obj3;
                                    object obj4;
                                    if (flag2 && (builder2.Length > 0))
                                    {
                                        builder.Append(builder2.ToString());
                                        builder2.Length = 0;
                                        flag3           = true;
                                    }
                                    flag2 = false;
                                    if (acceptedValues.TryGetValue(subsegment4.ParameterName, out obj3))
                                    {
                                        unusedNewValues.Remove(subsegment4.ParameterName);
                                    }
                                    defaultValues.TryGetValue(subsegment4.ParameterName, out obj4);
                                    if (RoutePartsEqual(obj3, obj4))
                                    {
                                        builder2.Append(UrlEncode(Convert.ToString(obj3, CultureInfo.InvariantCulture)));
                                    }
                                    else
                                    {
                                        if (builder2.Length > 0)
                                        {
                                            builder.Append(builder2.ToString());
                                            builder2.Length = 0;
                                        }
                                        builder.Append(UrlEncode(Convert.ToString(obj3, CultureInfo.InvariantCulture)));
                                        flag3 = true;
                                    }
                                }
                            }
                        }
                        if (flag3 && (builder2.Length > 0))
                        {
                            builder.Append(builder2.ToString());
                            builder2.Length = 0;
                        }
                    }
                }
            }
            if (flag2 && (builder2.Length > 0))
            {
                builder.Append(builder2.ToString());
            }
            if (constraints != null)
            {
                foreach (KeyValuePair <string, object> pair4 in constraints)
                {
                    unusedNewValues.Remove(pair4.Key);
                }
            }
            if (unusedNewValues.Count > 0)
            {
                bool flag5 = true;
                foreach (string str2 in unusedNewValues)
                {
                    object obj5;
                    if (acceptedValues.TryGetValue(str2, out obj5))
                    {
                        builder.Append(flag5 ? '?' : '&');
                        flag5 = false;
                        builder.Append(Uri.EscapeDataString(str2));
                        builder.Append('=');
                        builder.Append(Uri.EscapeDataString(Convert.ToString(obj5, CultureInfo.InvariantCulture)));
                    }
                }
            }
            return(new BoundUrl {
                Url = builder.ToString(), Values = acceptedValues
            });
        }
Beispiel #11
0
        private static Exception ValidateUrlSegment(IList <PathSubsegment> pathSubsegments, HashSet <string> usedParameterNames, string pathSegment)
        {
            bool segmentContainsCatchAll = false;

            Type previousSegmentType = null;

            foreach (PathSubsegment subsegment in pathSubsegments)
            {
                if (previousSegmentType != null)
                {
                    if (previousSegmentType == subsegment.GetType())
                    {
                        return(new ArgumentException(
                                   String.Format(
                                       CultureInfo.CurrentCulture,
                                       SR.GetString(SR.Route_CannotHaveConsecutiveParameters)
                                       ),
                                   "routeUrl"));
                    }
                }
                previousSegmentType = subsegment.GetType();

                LiteralSubsegment literalSubsegment = subsegment as LiteralSubsegment;
                if (literalSubsegment != null)
                {
                    // Nothing to validate for literals - everything is valid
                }
                else
                {
                    ParameterSubsegment parameterSubsegment = subsegment as ParameterSubsegment;
                    if (parameterSubsegment != null)
                    {
                        string parameterName = parameterSubsegment.ParameterName;

                        if (parameterSubsegment.IsCatchAll)
                        {
                            segmentContainsCatchAll = true;
                        }

                        // Check for valid characters in the parameter name
                        if (!IsValidParameterName(parameterName))
                        {
                            return(new ArgumentException(
                                       String.Format(
                                           CultureInfo.CurrentUICulture,
                                           SR.GetString(SR.Route_InvalidParameterName),
                                           parameterName
                                           ),
                                       "routeUrl"));
                        }

                        if (usedParameterNames.Contains(parameterName))
                        {
                            return(new ArgumentException(
                                       String.Format(
                                           CultureInfo.CurrentUICulture,
                                           SR.GetString(SR.Route_RepeatedParameter),
                                           parameterName
                                           ),
                                       "routeUrl"));
                        }
                        else
                        {
                            usedParameterNames.Add(parameterName);
                        }
                    }
                    else
                    {
                        Debug.Fail("Invalid path subsegment type");
                    }
                }
            }

            if (segmentContainsCatchAll && (pathSubsegments.Count != 1))
            {
                return(new ArgumentException(
                           String.Format(
                               CultureInfo.CurrentCulture,
                               SR.GetString(SR.Route_CannotHaveCatchAllInMultiSegment)
                               ),
                           "routeUrl"));
            }

            return(null);
        }
        private bool MatchContentPathSegment(ContentPathSegment routeSegment, string requestPathSegment, RouteValueDictionary defaultValues, RouteValueDictionary matchedValues)
        {
            if (String.IsNullOrEmpty(requestPathSegment))
            {
                // If there's no data to parse, we must have exactly one parameter segment and no other segments - otherwise no match

                if (routeSegment.Subsegments.Count > 1)
                {
                    return(false);
                }

                ParameterSubsegment parameterSubsegment = routeSegment.Subsegments[0] as ParameterSubsegment;
                if (parameterSubsegment == null)
                {
                    return(false);
                }

                // We must have a default value since there's no value in the request URL
                object parameterValue;
                if (defaultValues.TryGetValue(parameterSubsegment.ParameterName, out parameterValue))
                {
                    // If there's a default value for this parameter, use that default value
                    matchedValues.Add(parameterSubsegment.ParameterName, parameterValue);
                    return(true);
                }
                else
                {
                    // If there's no default value, this segment doesn't match
                    return(false);
                }
            }


            // Find last literal segment and get its last index in the string

            int lastIndex = requestPathSegment.Length;
            int indexOfLastSegmentUsed = routeSegment.Subsegments.Count - 1;

            ParameterSubsegment parameterNeedsValue = null; // Keeps track of a parameter segment that is pending a value
            LiteralSubsegment   lastLiteral         = null; // Keeps track of the left-most literal we've encountered

            while (indexOfLastSegmentUsed >= 0)
            {
                int newLastIndex = lastIndex;

                ParameterSubsegment parameterSubsegment = routeSegment.Subsegments[indexOfLastSegmentUsed] as ParameterSubsegment;
                if (parameterSubsegment != null)
                {
                    // Hold on to the parameter so that we can fill it in when we locate the next literal
                    parameterNeedsValue = parameterSubsegment;
                }
                else
                {
                    LiteralSubsegment literalSubsegment = routeSegment.Subsegments[indexOfLastSegmentUsed] as LiteralSubsegment;
                    if (literalSubsegment != null)
                    {
                        lastLiteral = literalSubsegment;

                        int startIndex = lastIndex - 1;
                        // If we have a pending parameter subsegment, we must leave at least one character for that
                        if (parameterNeedsValue != null)
                        {
                            startIndex--;
                        }

                        if (startIndex < 0)
                        {
                            return(false);
                        }

                        int indexOfLiteral = requestPathSegment.LastIndexOf(literalSubsegment.Literal, startIndex, StringComparison.OrdinalIgnoreCase);
                        if (indexOfLiteral == -1)
                        {
                            // If we couldn't find this literal index, this segment cannot match
                            return(false);
                        }

                        // If the first subsegment is a literal, it must match at the right-most extent of the request URL.
                        // Without this check if your route had "/Foo/" we'd match the request URL "/somethingFoo/".
                        // This check is related to the check we do at the very end of this function.
                        if (indexOfLastSegmentUsed == (routeSegment.Subsegments.Count - 1))
                        {
                            if ((indexOfLiteral + literalSubsegment.Literal.Length) != requestPathSegment.Length)
                            {
                                return(false);
                            }
                        }

                        newLastIndex = indexOfLiteral;
                    }
                    else
                    {
                        Debug.Fail("Invalid path segment type");
                    }
                }

                if ((parameterNeedsValue != null) && (((lastLiteral != null) && (parameterSubsegment == null)) || (indexOfLastSegmentUsed == 0)))
                {
                    // If we have a pending parameter that needs a value, grab that value

                    int parameterStartIndex;
                    int parameterTextLength;

                    if (lastLiteral == null)
                    {
                        if (indexOfLastSegmentUsed == 0)
                        {
                            parameterStartIndex = 0;
                        }
                        else
                        {
                            parameterStartIndex = newLastIndex;
                            Debug.Fail("indexOfLastSegementUsed should always be 0 from the check above");
                        }
                        parameterTextLength = lastIndex;
                    }
                    else
                    {
                        // If we're getting a value for a parameter that is somewhere in the middle of the segment
                        if ((indexOfLastSegmentUsed == 0) && (parameterSubsegment != null))
                        {
                            parameterStartIndex = 0;
                            parameterTextLength = lastIndex;
                        }
                        else
                        {
                            parameterStartIndex = newLastIndex + lastLiteral.Literal.Length;
                            parameterTextLength = lastIndex - parameterStartIndex;
                        }
                    }

                    string parameterValueString = requestPathSegment.Substring(parameterStartIndex, parameterTextLength);

                    if (String.IsNullOrEmpty(parameterValueString))
                    {
                        // If we're here that means we have a segment that contains multiple sub-segments.
                        // For these segments all parameters must have non-empty values. If the parameter
                        // has an empty value it's not a match.
                        return(false);
                    }
                    else
                    {
                        // If there's a value in the segment for this parameter, use the subsegment value
                        matchedValues.Add(parameterNeedsValue.ParameterName, parameterValueString);
                    }

                    parameterNeedsValue = null;
                    lastLiteral         = null;
                }

                lastIndex = newLastIndex;
                indexOfLastSegmentUsed--;
            }

            // If the last subsegment is a parameter, it's OK that we didn't parse all the way to the left extent of
            // the string since the parameter will have consumed all the remaining text anyway. If the last subsegment
            // is a literal then we *must* have consumed the entire text in that literal. Otherwise we end up matching
            // the route "Foo" to the request URL "somethingFoo". Thus we have to check that we parsed the *entire*
            // request URL in order for it to be a match.
            // This check is related to the check we do earlier in this function for LiteralSubsegments.
            return((lastIndex == 0) || (routeSegment.Subsegments[0] is ParameterSubsegment));
        }
        public BoundUrl Bind(RouteValueDictionary currentValues, RouteValueDictionary values, RouteValueDictionary defaultValues, RouteValueDictionary constraints)
        {
            if (currentValues == null)
            {
                currentValues = new RouteValueDictionary();
            }
            if (values == null)
            {
                values = new RouteValueDictionary();
            }
            if (defaultValues == null)
            {
                defaultValues = new RouteValueDictionary();
            }


            // The set of values we should be using when generating the URL in this route
            RouteValueDictionary acceptedValues = new RouteValueDictionary();

            // Keep track of which new values have been used
            HashSet <string> unusedNewValues = new HashSet <string>(values.Keys, StringComparer.OrdinalIgnoreCase);


            // Step 1: Get the list of values we're going to try to use to match and generate this URL


            // Find out which entries in the URL are valid for the URL we want to generate.
            // If the URL 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>.
            ForEachParameter(PathSegments, delegate(ParameterSubsegment parameterSubsegment) {
                // If it's a parameter subsegment, examine the current value to see if it matches the new value
                string parameterName = parameterSubsegment.ParameterName;

                object newParameterValue;
                bool hasNewParameterValue = values.TryGetValue(parameterName, out newParameterValue);
                if (hasNewParameterValue)
                {
                    unusedNewValues.Remove(parameterName);
                }

                object currentParameterValue;
                bool hasCurrentParameterValue = currentValues.TryGetValue(parameterName, out currentParameterValue);

                if (hasNewParameterValue && hasCurrentParameterValue)
                {
                    if (!RoutePartsEqual(currentParameterValue, newParameterValue))
                    {
                        // Stop copying current values when we find one that doesn't match
                        return(false);
                    }
                }

                // If the parameter is a match, add it to the list of values we will use for URL generation
                if (hasNewParameterValue)
                {
                    if (IsRoutePartNonEmpty(newParameterValue))
                    {
                        acceptedValues.Add(parameterName, newParameterValue);
                    }
                }
                else
                {
                    if (hasCurrentParameterValue)
                    {
                        acceptedValues.Add(parameterName, currentParameterValue);
                    }
                }
                return(true);
            });

            // Add all remaining new values to the list of values we will use for URL generation
            foreach (var newValue in values)
            {
                if (IsRoutePartNonEmpty(newValue.Value))
                {
                    if (!acceptedValues.ContainsKey(newValue.Key))
                    {
                        acceptedValues.Add(newValue.Key, newValue.Value);
                    }
                }
            }

            // Add all current values that aren't in the URL at all
            foreach (var currentValue in currentValues)
            {
                string parameterName = currentValue.Key;
                if (!acceptedValues.ContainsKey(parameterName))
                {
                    ParameterSubsegment parameterSubsegment = GetParameterSubsegment(PathSegments, parameterName);
                    if (parameterSubsegment == null)
                    {
                        acceptedValues.Add(parameterName, currentValue.Value);
                    }
                }
            }

            // Add all remaining default values from the route to the list of values we will use for URL generation
            ForEachParameter(PathSegments, delegate(ParameterSubsegment parameterSubsegment) {
                if (!acceptedValues.ContainsKey(parameterSubsegment.ParameterName))
                {
                    object defaultValue;
                    if (!IsParameterRequired(parameterSubsegment, defaultValues, out 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, which we determine based on whether
                        // the parameter value is required.
                        acceptedValues.Add(parameterSubsegment.ParameterName, defaultValue);
                    }
                }
                return(true);
            });


            // All required parameters in this URL must have values from somewhere (i.e. the accepted values)
            bool hasAllRequiredValues = ForEachParameter(PathSegments, delegate(ParameterSubsegment parameterSubsegment) {
                object defaultValue;
                if (IsParameterRequired(parameterSubsegment, defaultValues, out defaultValue))
                {
                    if (!acceptedValues.ContainsKey(parameterSubsegment.ParameterName))
                    {
                        // If the route parameter value is required that means there's
                        // no default value, so if there wasn't a new value for it
                        // either, this route won't match.
                        return(false);
                    }
                }
                return(true);
            });

            if (!hasAllRequiredValues)
            {
                return(null);
            }

            // All other default values must match if they are explicitly defined in the new values
            RouteValueDictionary otherDefaultValues = new RouteValueDictionary(defaultValues);

            ForEachParameter(PathSegments, delegate(ParameterSubsegment parameterSubsegment) {
                otherDefaultValues.Remove(parameterSubsegment.ParameterName);
                return(true);
            });

            foreach (var defaultValue in otherDefaultValues)
            {
                object value;
                if (values.TryGetValue(defaultValue.Key, out value))
                {
                    unusedNewValues.Remove(defaultValue.Key);
                    if (!RoutePartsEqual(value, defaultValue.Value))
                    {
                        // 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.
                        return(null);
                    }
                }
            }


            // Step 2: If the route is a match generate the appropriate URL

            StringBuilder url          = new StringBuilder();
            StringBuilder pendingParts = new StringBuilder();

            bool pendingPartsAreAllSafe = false;
            bool blockAllUrlAppends     = false;

            for (int i = 0; i < PathSegments.Count; i++)
            {
                PathSegment pathSegment = PathSegments[i]; // parsedRouteUrlPart

                if (pathSegment is SeparatorPathSegment)
                {
                    if (pendingPartsAreAllSafe)
                    {
                        // Accept
                        if (pendingParts.Length > 0)
                        {
                            if (blockAllUrlAppends)
                            {
                                return(null);
                            }

                            // Append any pending literals to the URL
                            url.Append(pendingParts.ToString());
                            pendingParts.Length = 0;
                        }
                    }
                    pendingPartsAreAllSafe = false;

                    // Guard against appending multiple separators for empty segements
                    if (pendingParts.Length > 0 && pendingParts[pendingParts.Length - 1] == '/')
                    {
                        // Dev10 676725: Route should not be matched if that causes mismatched tokens
                        // Dev11 86819: We will allow empty matches if all subsequent segments are null
                        if (blockAllUrlAppends)
                        {
                            return(null);
                        }

                        // Append any pending literals to the URL(without the trailing slash) and prevent any future appends
                        url.Append(pendingParts.ToString(0, pendingParts.Length - 1));
                        pendingParts.Length = 0;
                        blockAllUrlAppends  = true;
                    }
                    else
                    {
                        pendingParts.Append("/");
                    }
                }
                else
                {
                    ContentPathSegment contentPathSegment = pathSegment as ContentPathSegment;
                    if (contentPathSegment != null)
                    {
                        // Segments are treated as all-or-none. We should never output a partial segment.
                        // If we add any subsegment of this segment to the generated URL, we have to add
                        // the complete match. For example, if the subsegment is "{p1}-{p2}.xml" and we
                        // used a value for {p1}, we have to output the entire segment up to the next "/".
                        // Otherwise we could end up with the partial segment "v1" instead of the entire
                        // segment "v1-v2.xml".
                        bool addedAnySubsegments = false;

                        foreach (PathSubsegment subsegment in contentPathSegment.Subsegments)
                        {
                            LiteralSubsegment literalSubsegment = subsegment as LiteralSubsegment;
                            if (literalSubsegment != null)
                            {
                                // If it's a literal we hold on to it until we are sure we need to add it
                                pendingPartsAreAllSafe = true;
                                pendingParts.Append(UrlEncode(literalSubsegment.Literal));
                            }
                            else
                            {
                                ParameterSubsegment parameterSubsegment = subsegment as ParameterSubsegment;
                                if (parameterSubsegment != null)
                                {
                                    if (pendingPartsAreAllSafe)
                                    {
                                        // Accept
                                        if (pendingParts.Length > 0)
                                        {
                                            if (blockAllUrlAppends)
                                            {
                                                return(null);
                                            }

                                            // Append any pending literals to the URL
                                            url.Append(pendingParts.ToString());
                                            pendingParts.Length = 0;

                                            addedAnySubsegments = true;
                                        }
                                    }
                                    pendingPartsAreAllSafe = false;

                                    // If it's a parameter, get its value
                                    object acceptedParameterValue;
                                    bool   hasAcceptedParameterValue = acceptedValues.TryGetValue(parameterSubsegment.ParameterName, out acceptedParameterValue);
                                    if (hasAcceptedParameterValue)
                                    {
                                        unusedNewValues.Remove(parameterSubsegment.ParameterName);
                                    }

                                    object defaultParameterValue;
                                    defaultValues.TryGetValue(parameterSubsegment.ParameterName, out defaultParameterValue);

                                    if (RoutePartsEqual(acceptedParameterValue, defaultParameterValue))
                                    {
                                        // If the accepted value is the same as the default value, mark it as pending since
                                        // we won't necessarily add it to the URL we generate.
                                        pendingParts.Append(UrlEncode(Convert.ToString(acceptedParameterValue, CultureInfo.InvariantCulture)));
                                    }
                                    else
                                    {
                                        if (blockAllUrlAppends)
                                        {
                                            return(null);
                                        }

                                        // Add the new part to the URL as well as any pending parts
                                        if (pendingParts.Length > 0)
                                        {
                                            // Append any pending literals to the URL
                                            url.Append(pendingParts.ToString());
                                            pendingParts.Length = 0;
                                        }
                                        url.Append(UrlEncode(Convert.ToString(acceptedParameterValue, CultureInfo.InvariantCulture)));

                                        addedAnySubsegments = true;
                                    }
                                }
                                else
                                {
                                    Debug.Fail("Invalid path subsegment type");
                                }
                            }
                        }

                        if (addedAnySubsegments)
                        {
                            // See comment above about why we add the pending parts
                            if (pendingParts.Length > 0)
                            {
                                if (blockAllUrlAppends)
                                {
                                    return(null);
                                }

                                // Append any pending literals to the URL
                                url.Append(pendingParts.ToString());
                                pendingParts.Length = 0;
                            }
                        }
                    }
                    else
                    {
                        Debug.Fail("Invalid path segment type");
                    }
                }
            }

            if (pendingPartsAreAllSafe)
            {
                // Accept
                if (pendingParts.Length > 0)
                {
                    if (blockAllUrlAppends)
                    {
                        return(null);
                    }

                    // Append any pending literals to the URL
                    url.Append(pendingParts.ToString());
                }
            }

            // Process constraints keys
            if (constraints != null)
            {
                // If there are any constraints, mark all the keys as being used so that we don't
                // generate query string items for custom constraints that don't appear as parameters
                // in the URL format.
                foreach (var constraintsItem in constraints)
                {
                    unusedNewValues.Remove(constraintsItem.Key);
                }
            }


            // Add remaining new values as query string parameters to the URL
            if (unusedNewValues.Count > 0)
            {
                // Generate the query string
                bool firstParam = true;
                foreach (string unusedNewValue in unusedNewValues)
                {
                    object value;
                    if (acceptedValues.TryGetValue(unusedNewValue, out value))
                    {
                        url.Append(firstParam ? '?' : '&');
                        firstParam = false;
                        url.Append(Uri.EscapeDataString(unusedNewValue));
                        url.Append('=');
                        url.Append(Uri.EscapeDataString(Convert.ToString(value, CultureInfo.InvariantCulture)));
                    }
                }
            }

            return(new BoundUrl {
                Url = url.ToString(),
                Values = acceptedValues
            });
        }