public override string SelectAction(ODataPath odataPath, HttpControllerContext controllerContext, ILookup<string, HttpActionDescriptor> actionMap)
        {
            var action = base.SelectAction(odataPath, controllerContext, actionMap);
            if (action != null)
            {
                var routeValues = controllerContext.RouteData.Values;
                if (routeValues.ContainsKey(ODataRouteConstants.Key))
                {
                    var keyRaw = routeValues[ODataRouteConstants.Key] as string;
                    IEnumerable<string> compoundKeyPairs = keyRaw.Split(',');
                    if (compoundKeyPairs == null || !compoundKeyPairs.Any())
                    {
                        return action;
                    }

                    foreach (var compoundKeyPair in compoundKeyPairs)
                    {
                        string[] pair = compoundKeyPair.Split('=');
                        if (pair == null || pair.Length != 2)
                        {
                            continue;
                        }
                        var keyName = pair[0].Trim();
                        var keyValue = pair[1].Trim();

                        routeValues.Add(keyName, keyValue);
                    }
                }
            }

            return action;
        }

 public string SelectController(ODataPath odataPath, HttpRequestMessage request)
 {
     var controller = delegateRoutingConvention.SelectController(odataPath, request);
     return string.Equals(controller, controllerAlias, StringComparison.OrdinalIgnoreCase)
         ? targetControllerName
         : controller;
 }

        public string SelectAction(ODataPath odataPath, HttpControllerContext controllerContext, ILookup<string, HttpActionDescriptor> actionMap)
        {
            if (odataPath.PathTemplate != "~/entityset/key/property")
            {
                return null;
            }

            var entitySetPathSegment = odataPath.Segments.OfType<EntitySetPathSegment>().Single();
            var keyValuePathSegment = odataPath.Segments.OfType<KeyValuePathSegment>().Single();
            var propertyAccessPathSegment = odataPath.Segments.OfType<PropertyAccessPathSegment>().Single();

            var actionName = string.Format(CultureInfo.InvariantCulture, "GetPropertyFrom{0}", entitySetPathSegment.EntitySetName);

            if (actionMap.Contains(actionName) && actionMap[actionName].Any(desc => MatchHttpMethod(desc, controllerContext.Request.Method)))
            {
                controllerContext.RouteData.Values.Add("propertyName", propertyAccessPathSegment.PropertyName);

                if (!CompositeODataKeyHelper.TryEnrichRouteValues(keyValuePathSegment.Value, controllerContext.RouteData.Values))
                {
                    controllerContext.RouteData.Values.Add("key", keyValuePathSegment.Value);
                }

                return actionName;
            }

            return null;
        }

        public override string SelectAction(ODataPath odataPath, HttpControllerContext context,
            ILookup<string, HttpActionDescriptor> actionMap)
        {
            if (context.Request.Method == HttpMethod.Get &&
                odataPath.PathTemplate == "~/entityset/key/navigation/key")
            {
                NavigationPathSegment navigationSegment = odataPath.Segments[2] as NavigationPathSegment;
                IEdmNavigationProperty navigationProperty = navigationSegment.NavigationProperty.Partner;
                IEdmEntityType declaringType = navigationProperty.DeclaringType as IEdmEntityType;

                string actionName = "Get" + declaringType.Name;
                if (actionMap.Contains(actionName))
                {
                    // Add keys to route data, so they will bind to action parameters.
                    KeyValuePathSegment keyValueSegment = odataPath.Segments[1] as KeyValuePathSegment;
                    context.RouteData.Values[ODataRouteConstants.Key] = keyValueSegment.Value;

                    KeyValuePathSegment relatedKeySegment = odataPath.Segments[3] as KeyValuePathSegment;
                    context.RouteData.Values[ODataRouteConstants.RelatedKey] = relatedKeySegment.Value;

                    return actionName;
                }
            }
            // Not a match.
            return null;
        }

 public string SelectController(ODataPath odataPath, HttpRequestMessage request)
 {
     if (odataPath.PathTemplate == "~/action/$count")
     {
         return controllerName;
     }
     return null;
 }

 public string SelectController(ODataPath odataPath, HttpRequestMessage request)
 {
     if (odataPath.PathTemplate == "~/entityset/key/property")
     {
         return _controllerName;
     }
     return null;
 }

 // Route all non-bindable actions to a single controller.
 public string SelectController(ODataPath odataPath, System.Net.Http.HttpRequestMessage request)
 {
     if (odataPath.PathTemplate == "~/action")
     {
         return _controllerName;
     }
     return null;
 }

        public override string SelectAction(ODataPath odataPath, HttpControllerContext controllerContext, ILookup<string, HttpActionDescriptor> actionMap)
        {
            if (controllerContext.Request.Method != HttpMethod.Get || odataPath.PathTemplate != "~/entityset/$count")
            {
                return null;
            }

            return actionMap.Contains("GetCount") ? "GetCount" : null;
        }

        private static IEdmNavigationProperty GetNavigationProperty(ODataPath path)
        {
            if (path == null)
            {
                throw new SerializationException(SRResources.ODataPathMissing);
            }

            return path.GetNavigationProperty();
        }

 public override string SelectAction(ODataPath odataPath, HttpControllerContext controllerContext, ILookup<string, HttpActionDescriptor> actionMap)
 {
     string result = base.SelectAction(odataPath, controllerContext, actionMap);
     IDictionary<string, object> conventionStore = controllerContext.Request.ODataProperties().RoutingConventionsStore;
     if (result != null && conventionStore != null)
     {
         conventionStore["keyAsCustomer"] = new BindCustomer { Id = int.Parse((string)controllerContext.RouteData.Values["key"]) };
     }
     return result;
 }

 private static void AddLinkInfoToRouteData(IHttpRouteData routeData, ODataPath odataPath)
 {
     KeyValuePathSegment keyValueSegment = odataPath.Segments.OfType<KeyValuePathSegment>().First();
     routeData.Values[ODataRouteConstants.Key] = keyValueSegment.Value;
     KeyValuePathSegment relatedKeySegment = odataPath.Segments.Last() as KeyValuePathSegment;
     if (relatedKeySegment != null)
     {
         routeData.Values[ODataRouteConstants.RelatedKey] = relatedKeySegment.Value;
     }
 }

        public override string SelectAction(ODataPath odataPath, HttpControllerContext controllerContext, ILookup<string, HttpActionDescriptor> actionMap)
        {
            if (odataPath == null)
            {
                throw new ArgumentNullException("odataPath");
            }
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }
            if (actionMap == null)
            {
                throw new ArgumentNullException("actionMap");
            }
            HttpMethod requestMethod = controllerContext.Request.Method;
            if (odataPath.PathTemplate == "~/entityset/key/$links/navigation" 
                || odataPath.PathTemplate == "~/entityset/key/cast/$links/navigation"
                || odataPath.PathTemplate == "~/entityset/key/$links/navigation/key"
                || odataPath.PathTemplate == "~/entityset/key/cast/$links/navigation/key")
            {
                var actionName = string.Empty;
                if ((requestMethod == HttpMethod.Post) || (requestMethod == HttpMethod.Put))
                {
                    actionName += "CreateLinkTo";
                }
                else if (requestMethod == HttpMethod.Delete)
                {
                    actionName += "DeleteLinkTo";
                }
                else
                {
                    return null;
                }
                var navigationSegment = odataPath.Segments.OfType<NavigationPathSegment>().Last();
                actionName += navigationSegment.NavigationPropertyName;

                var castSegment = odataPath.Segments[2] as CastPathSegment;
                if (castSegment != null)
                {
                    var actionCastName = string.Format("{0}On{1}", actionName, castSegment.CastType.Name);
                    if (actionMap.Contains(actionCastName))
                    {
                        AddLinkInfoToRouteData(controllerContext.RouteData, odataPath);
                        return actionCastName;
                    }
                }

                if (actionMap.Contains(actionName))
                {
                    AddLinkInfoToRouteData(controllerContext.RouteData, odataPath);
                    return actionName;
                }
            }
            return null;
        }

        public void WriteObject_Throws_ObjectCannotBeWritten_IfGraphIsNotUri()
        {
            IEdmNavigationProperty navigationProperty = _customerSet.ElementType.NavigationProperties().First();
            ODataEntityReferenceLinksSerializer serializer = new ODataEntityReferenceLinksSerializer();
            ODataPath path = new ODataPath(new NavigationPathSegment(navigationProperty));
            ODataSerializerContext writeContext = new ODataSerializerContext { EntitySet = _customerSet, Path = path };

            Assert.Throws<SerializationException>(
                () => serializer.WriteObject(graph: "not uri", messageWriter: ODataTestUtil.GetMockODataMessageWriter(), writeContext: writeContext),
                "ODataEntityReferenceLinksSerializer cannot write an object of type 'System.String'.");
        }

        public override string SelectAction(ODataPath odataPath, HttpControllerContext controllerContext, ILookup<string, HttpActionDescriptor> actionMap)
        {
            var action = base.SelectAction(odataPath, controllerContext, actionMap);

            if (action != null)
            {
                controllerContext.RouteData.DecomposeKey();
            }

            return action;
        }

        public void ToStringWithNoSegments()
        {
            // Arrange
            ODataPath path = new ODataPath();

            // Act
            string value = path.ToString();

            // Assert
            Assert.Empty(value);
        }

        public virtual string SelectAction(ODataPath odataPath, HttpControllerContext controllerContext, ILookup<string, HttpActionDescriptor> actionMap)
        {
            var action = entityRoutingConvention.SelectAction(odataPath, controllerContext, actionMap);
            if (action == null)
            {
                return null;
            }

            controllerContext.RouteData.DecomposeKey();

            return action;
        }

        public void ToStringWithOneSegment()
        {
            // Arrange
            string expectedValue = "Set";
            ODataPath path = new ODataPath(new EntitySetPathSegment(expectedValue));

            // Act
            string value = path.ToString();

            // Assert
            Assert.Equal(expectedValue, value);
        }

		public override string SelectAction(ODataPath odataPath, HttpControllerContext controllerContext, ILookup<string, HttpActionDescriptor> actionMap)
		{
			if (odataPath == null)
			{
				throw new ArgumentNullException("odataPath");
			}
			if (controllerContext == null)
			{
				throw new ArgumentNullException("controllerContext");
			}
			if (actionMap == null)
			{
				throw new ArgumentNullException("actionMap");
			}

			IEdmNavigationProperty navigationProperty = GetNavigationProperty(odataPath);
			IEdmEntityType declaringType = navigationProperty == null ? null : navigationProperty.DeclaringType as IEdmEntityType;

			if (declaringType != null)
			{
				HttpMethod httpMethod = controllerContext.Request.Method;
				string actionName = null;

				if (IsNavigationPropertyValuePath(odataPath))
				{
					if (httpMethod == HttpMethod.Get)
					{
						actionName = actionMap.FindMatchingAction("Get" + navigationProperty.Name, GetNavigationPropertyMethodName);
					}
					else if (httpMethod == HttpMethod.Post)
					{
						actionName = actionMap.FindMatchingAction("Post" + navigationProperty.Name, PostNavigationPropertyMethodName);
					}
				}
				// Navigation property links are already handled by LinksRoutingConvention
				// else if (IsNavigationPropertyLinkPath(odataPath)) {}

				if (actionName != null)
				{
					KeyValuePathSegment keyValueSegment = odataPath.Segments[1] as KeyValuePathSegment;
					if (keyValueSegment != null)
					{
						controllerContext.RouteData.Values[ODataRouteConstants.Key] = keyValueSegment.Value;
					}

					controllerContext.RouteData.Values[ODataRouteConstants.NavigationProperty] = navigationProperty.Name;

					return actionName;
				}
			}
			return null;
		}

        public void ToStringWithKeyValueSegment()
        {
            // Arrange
            string segment = "1";
            ODataPath path = new ODataPath(new KeyValuePathSegment(segment));

            // Act
            string value = path.ToString();

            // Assert
            string expectedValue = "(" + segment + ")";
            Assert.Equal(expectedValue, value);
        }

		/// <summary>
		/// Selects the controller for OData requests.
		/// </summary>
		/// <param name="odataPath">The OData path.</param>
		/// <param name="request">The request.</param>
		/// <returns>
		///   <c>null</c> if the request isn't handled by this convention; otherwise, the name of the selected controller
		/// </returns>
		public string SelectController(ODataPath odataPath, HttpRequestMessage request)
		{
			//Contract.Requires<ArgumentNullException>(odataPath != null);
			//Contract.Requires<ArgumentNullException>(request != null);

			if (odataPath.PathTemplate == "~" ||
			    odataPath.PathTemplate == "~/$metadata")
			{
				return "EntityRepositoryMetadata";
			}

			return null;
		}