ParsedRoute.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / Routing / ParsedRoute.cs / 1305376 / ParsedRoute.cs

                            namespace System.Web.Routing { 
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Globalization;
    using System.Linq; 
    using System.Text;
    using System.Text.RegularExpressions; 
 
    internal sealed class ParsedRoute {
        public ParsedRoute(IList pathSegments) { 
            Debug.Assert(pathSegments != null);

            PathSegments = pathSegments;
        } 

        private IList PathSegments { 
            get; 
            set;
        } 

        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 unusedNewValues = new HashSet(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=. 
            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; 

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

                if (pathSegment is SeparatorPathSegment) { 
                    if (pendingPartsAreAllSafe) {
                        // Accept
                        if (pendingParts.Length > 0) {
                            // Append any pending literals to the URL 
                            url.Append(pendingParts.ToString());
                            pendingParts.Length = 0; 
                        } 
                    }
                    pendingPartsAreAllSafe = false; 

                    if (pendingParts.Length > 0 && pendingParts[pendingParts.Length-1] == '/') {
                        // Dev10 676725: Route should not be matched if that causes mismatched tokens
                        return null; 
                    }
                    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) { 
                                            // 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 {
                                        // 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) { 
                                // 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) {
                    // 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 
            };
        }

        private static string EscapeReservedCharacters(Match m) { 
            return "%" + Convert.ToUInt16(m.Value[0]).ToString("x2", CultureInfo.InvariantCulture);
        } 
 
        private static bool ForEachParameter(IList pathSegments, Func 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 static ParameterSubsegment GetParameterSubsegment(IList pathSegments, string parameterName) {
            ParameterSubsegment foundParameterSubsegment = null;
 
            bool continueProcessing = ForEachParameter(pathSegments, delegate(ParameterSubsegment parameterSubsegment) {
                if (String.Equals(parameterName, parameterSubsegment.ParameterName, StringComparison.OrdinalIgnoreCase)) { 
                    foundParameterSubsegment = parameterSubsegment; 
                    return false;
                } 
                else {
                    return true;
                }
            }); 

            return foundParameterSubsegment; 
        } 

        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 bool IsRoutePartNonEmpty(object routePart) { 
            string routePartString = routePart as string;
            if (routePartString != null) {
                return (routePartString.Length > 0);
            } 
            return (routePart != null);
        } 
 
        public RouteValueDictionary Match(string virtualPath, RouteValueDictionary defaultValues) {
            IList requestPathSegments = RouteParser.SplitUrlToPathSegmentStrings(virtualPath); 

            if (defaultValues == null) {
                defaultValues = new RouteValueDictionary();
            } 

            RouteValueDictionary matchedValues = new RouteValueDictionary(); 
 
            // This flag gets set once all the data in the URL has been parsed through, but
            // the route we're trying to match against still has more parts. At this point 
            // we'll only continue matching separator characters and parameters that have
            // default values.
            bool ranOutOfStuffToParse = false;
 
            // This value gets set once we start processing a catchall parameter (if there is one
            // at all). Once we set this value we consume all remaining parts of the URL into its 
            // parameter value. 
            bool usedCatchAllParameter = false;
 
            for (int i = 0; i < PathSegments.Count; i++) {
                PathSegment pathSegment = PathSegments[i];

                if (requestPathSegments.Count <= i) { 
                    ranOutOfStuffToParse = true;
                } 
 
                string requestPathSegment = ranOutOfStuffToParse ? null : requestPathSegments[i];
 
                if (pathSegment is SeparatorPathSegment) {
                    if (ranOutOfStuffToParse) {
                        // If we're trying to match a separator in the route but there's no more content, that's OK
                    } 
                    else {
                        if (!String.Equals(requestPathSegment, "/", StringComparison.Ordinal)) { 
                            return null; 
                        }
                    } 
                }
                else {
                    ContentPathSegment contentPathSegment = pathSegment as ContentPathSegment;
                    if (contentPathSegment != null) { 
                        if (contentPathSegment.IsCatchAll) {
                            Debug.Assert(i == (PathSegments.Count - 1), "If we're processing a catch-all, we should be on the last route segment."); 
                            MatchCatchAll(contentPathSegment, requestPathSegments.Skip(i), defaultValues, matchedValues); 
                            usedCatchAllParameter = true;
                        } 
                        else {
                            if (!MatchContentPathSegment(contentPathSegment, requestPathSegment, defaultValues, matchedValues)) {
                                return null;
                            } 
                        }
                    } 
                    else { 
                        Debug.Fail("Invalid path segment type");
                    } 
                }
            }

            if (!usedCatchAllParameter) { 
                if (PathSegments.Count < requestPathSegments.Count) {
                    // If we've already gone through all the parts defined in the route but the URL 
                    // still contains more content, check that the remaining content is all separators. 
                    for (int i = PathSegments.Count; i < requestPathSegments.Count; i++) {
                        if (!RouteParser.IsSeparator(requestPathSegments[i])) { 
                            return null;
                        }
                    }
                } 
            }
 
            // Copy all remaining default values to the route data 
            if (defaultValues != null) {
                foreach (var defaultValue in defaultValues) { 
                    if (!matchedValues.ContainsKey(defaultValue.Key)) {
                        matchedValues.Add(defaultValue.Key, defaultValue.Value);
                    }
                } 
            }
 
            return matchedValues; 
        }
 
        private void MatchCatchAll(ContentPathSegment contentPathSegment, IEnumerable 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);
        } 
 
        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 + lastLiteral.Literal.Length; 
                        }
                        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); 
        }
 
        private static bool RoutePartsEqual(object a, object b) {
            string sa = a as string;
            string sb = b as string;
            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; 
                } 
            }
        } 

        // Dev10 601636 Work around Uri.EscapeUriString not encoding #,&
        private static string UrlEncode(string str) {
            string escape = Uri.EscapeUriString(str); 
            return Regex.Replace(escape, "([#;?:@&=+$,])", new MatchEvaluator(EscapeReservedCharacters));
        } 
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
´╗┐namespace System.Web.Routing { 
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Globalization;
    using System.Linq; 
    using System.Text;
    using System.Text.RegularExpressions; 
 
    internal sealed class ParsedRoute {
        public ParsedRoute(IList pathSegments) { 
            Debug.Assert(pathSegments != null);

            PathSegments = pathSegments;
        } 

        private IList PathSegments { 
            get; 
            set;
        } 

        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 unusedNewValues = new HashSet(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=. 
            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; 

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

                if (pathSegment is SeparatorPathSegment) { 
                    if (pendingPartsAreAllSafe) {
                        // Accept
                        if (pendingParts.Length > 0) {
                            // Append any pending literals to the URL 
                            url.Append(pendingParts.ToString());
                            pendingParts.Length = 0; 
                        } 
                    }
                    pendingPartsAreAllSafe = false; 

                    if (pendingParts.Length > 0 && pendingParts[pendingParts.Length-1] == '/') {
                        // Dev10 676725: Route should not be matched if that causes mismatched tokens
                        return null; 
                    }
                    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) { 
                                            // 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 {
                                        // 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) { 
                                // 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) {
                    // 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 
            };
        }

        private static string EscapeReservedCharacters(Match m) { 
            return "%" + Convert.ToUInt16(m.Value[0]).ToString("x2", CultureInfo.InvariantCulture);
        } 
 
        private static bool ForEachParameter(IList pathSegments, Func 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 static ParameterSubsegment GetParameterSubsegment(IList pathSegments, string parameterName) {
            ParameterSubsegment foundParameterSubsegment = null;
 
            bool continueProcessing = ForEachParameter(pathSegments, delegate(ParameterSubsegment parameterSubsegment) {
                if (String.Equals(parameterName, parameterSubsegment.ParameterName, StringComparison.OrdinalIgnoreCase)) { 
                    foundParameterSubsegment = parameterSubsegment; 
                    return false;
                } 
                else {
                    return true;
                }
            }); 

            return foundParameterSubsegment; 
        } 

        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 bool IsRoutePartNonEmpty(object routePart) { 
            string routePartString = routePart as string;
            if (routePartString != null) {
                return (routePartString.Length > 0);
            } 
            return (routePart != null);
        } 
 
        public RouteValueDictionary Match(string virtualPath, RouteValueDictionary defaultValues) {
            IList requestPathSegments = RouteParser.SplitUrlToPathSegmentStrings(virtualPath); 

            if (defaultValues == null) {
                defaultValues = new RouteValueDictionary();
            } 

            RouteValueDictionary matchedValues = new RouteValueDictionary(); 
 
            // This flag gets set once all the data in the URL has been parsed through, but
            // the route we're trying to match against still has more parts. At this point 
            // we'll only continue matching separator characters and parameters that have
            // default values.
            bool ranOutOfStuffToParse = false;
 
            // This value gets set once we start processing a catchall parameter (if there is one
            // at all). Once we set this value we consume all remaining parts of the URL into its 
            // parameter value. 
            bool usedCatchAllParameter = false;
 
            for (int i = 0; i < PathSegments.Count; i++) {
                PathSegment pathSegment = PathSegments[i];

                if (requestPathSegments.Count <= i) { 
                    ranOutOfStuffToParse = true;
                } 
 
                string requestPathSegment = ranOutOfStuffToParse ? null : requestPathSegments[i];
 
                if (pathSegment is SeparatorPathSegment) {
                    if (ranOutOfStuffToParse) {
                        // If we're trying to match a separator in the route but there's no more content, that's OK
                    } 
                    else {
                        if (!String.Equals(requestPathSegment, "/", StringComparison.Ordinal)) { 
                            return null; 
                        }
                    } 
                }
                else {
                    ContentPathSegment contentPathSegment = pathSegment as ContentPathSegment;
                    if (contentPathSegment != null) { 
                        if (contentPathSegment.IsCatchAll) {
                            Debug.Assert(i == (PathSegments.Count - 1), "If we're processing a catch-all, we should be on the last route segment."); 
                            MatchCatchAll(contentPathSegment, requestPathSegments.Skip(i), defaultValues, matchedValues); 
                            usedCatchAllParameter = true;
                        } 
                        else {
                            if (!MatchContentPathSegment(contentPathSegment, requestPathSegment, defaultValues, matchedValues)) {
                                return null;
                            } 
                        }
                    } 
                    else { 
                        Debug.Fail("Invalid path segment type");
                    } 
                }
            }

            if (!usedCatchAllParameter) { 
                if (PathSegments.Count < requestPathSegments.Count) {
                    // If we've already gone through all the parts defined in the route but the URL 
                    // still contains more content, check that the remaining content is all separators. 
                    for (int i = PathSegments.Count; i < requestPathSegments.Count; i++) {
                        if (!RouteParser.IsSeparator(requestPathSegments[i])) { 
                            return null;
                        }
                    }
                } 
            }
 
            // Copy all remaining default values to the route data 
            if (defaultValues != null) {
                foreach (var defaultValue in defaultValues) { 
                    if (!matchedValues.ContainsKey(defaultValue.Key)) {
                        matchedValues.Add(defaultValue.Key, defaultValue.Value);
                    }
                } 
            }
 
            return matchedValues; 
        }
 
        private void MatchCatchAll(ContentPathSegment contentPathSegment, IEnumerable 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);
        } 
 
        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 + lastLiteral.Literal.Length; 
                        }
                        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); 
        }
 
        private static bool RoutePartsEqual(object a, object b) {
            string sa = a as string;
            string sb = b as string;
            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; 
                } 
            }
        } 

        // Dev10 601636 Work around Uri.EscapeUriString not encoding #,&
        private static string UrlEncode(string str) {
            string escape = Uri.EscapeUriString(str); 
            return Regex.Replace(escape, "([#;?:@&=+$,])", new MatchEvaluator(EscapeReservedCharacters));
        } 
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK