/// <summary>
        /// Builds a mapping of constraints.
        /// </summary>
        /// <returns>An <see cref="IDictionary{string, IRouteConstraint}"/> of the constraints.</returns>
        public IDictionary<string, IRouteConstraint> Build()
        {
            var constraints = new Dictionary<string, IRouteConstraint>(StringComparer.OrdinalIgnoreCase);
            foreach (var kvp in _constraints)
            {
                IRouteConstraint constraint;
                if (kvp.Value.Count == 1)
                {
                    constraint = kvp.Value[0];
                }
                else
                {
                    constraint = new CompositeRouteConstraint(kvp.Value.ToArray());
                }

                if (_optionalParameters.Contains(kvp.Key))
                {
                    var optionalConstraint = new OptionalRouteConstraint(constraint);
                    constraints.Add(kvp.Key, optionalConstraint);
                }
                else
                {
                    constraints.Add(kvp.Key, constraint);
                }
            }

            return constraints;
        }
示例#2
0
        /// <summary>
        /// Builds a mapping of constraints.
        /// </summary>
        /// <returns>An <see cref="IDictionary{String, IRouteConstraint}"/> of the constraints.</returns>
        public IDictionary <string, IRouteConstraint> Build()
        {
            var constraints = new Dictionary <string, IRouteConstraint>(StringComparer.OrdinalIgnoreCase);

            foreach (var kvp in _constraints)
            {
                IRouteConstraint constraint;
                if (kvp.Value.Count == 1)
                {
                    constraint = kvp.Value[0];
                }
                else
                {
                    constraint = new CompositeRouteConstraint(kvp.Value.ToArray());
                }

                if (_optionalParameters.Contains(kvp.Key))
                {
                    var optionalConstraint = new OptionalRouteConstraint(constraint);
                    constraints.Add(kvp.Key, optionalConstraint);
                }
                else
                {
                    constraints.Add(kvp.Key, constraint);
                }
            }

            return(constraints);
        }
        private IEnumerable <QualifiedRoute> ResolveFullMethodRoutes(string route,
                                                                     IRouteConstraint constraint, object dataTokens)
        {
            if (_handlerRoutes != null)
            {
                foreach (var hr in _handlerRoutes)
                {
                    var t = route;
                    if (!string.IsNullOrEmpty(hr.Template))
                    {
                        t = $"{hr.Template.TrimEnd('/')}/{t.TrimStart('/')}";
                    }
                    var c = constraint;
                    if (c == null)
                    {
                        c = hr.Constraint;
                    }
                    else if (hr.Constraint != null)
                    {
                        c = new CompositeRouteConstraint(new[] { c, constraint });
                    }

                    yield return(new QualifiedRoute(t, c, dataTokens));
                }
            }
            else
            {
                yield return(new QualifiedRoute(route, constraint, dataTokens));
            }
        }
        public void CompositeRouteConstraint_Match_CallsMatchOnInnerConstraints(bool inner1Result,
                                                                                bool inner2Result,
                                                                                bool expected)
        {
            // Arrange
            var inner1 = MockConstraintWithResult(inner1Result);
            var inner2 = MockConstraintWithResult(inner2Result);

            // Act
            var constraint = new CompositeRouteConstraint(new[] { inner1.Object, inner2.Object });
            var actual     = ConstraintsTestHelper.TestConstraint(constraint, null);

            // Assert
            Assert.Equal(expected, actual);
        }
        public void CompositeRouteConstraint_Match_CallsMatchOnInnerConstraints(bool inner1Result,
                                                                               bool inner2Result,
                                                                               bool expected)
        {
            // Arrange
            var inner1 = MockConstraintWithResult(inner1Result);
            var inner2 = MockConstraintWithResult(inner2Result);

            // Act
            var constraint = new CompositeRouteConstraint(new[] { inner1.Object, inner2.Object });
            var actual = ConstraintsTestHelper.TestConstraint(constraint, null);

            // Assert
            Assert.Equal(expected, actual);
        }