protected RouteTest(string url, HttpMethod httpMethod) { HttpRequestMessage = new HttpRequestMessage(httpMethod, url); HttpRequestMessage.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, GlobalConfiguration.Configuration); // if (HttpRequestMessage == null) foreach (IHttpRoute httpRoute in GlobalConfiguration.Configuration.Routes) //GlobalConfiguration.Configuration.Routes.VirtualPathRoot = "sdf"; { IHttpRouteData routeData = httpRoute.GetRouteData("http://test.com/", HttpRequestMessage); if (routeData != null) { var d = routeData; } } var r = (IHttpRouteData)null; var route = new HttpRouteData(new HttpRoute()); HttpRouteData = GlobalConfiguration.Configuration.Routes.GetRouteData(HttpRequestMessage); HttpRequestMessage.Properties[HttpPropertyKeys.HttpRouteDataKey] = HttpRouteData; ControllerSelector = new DefaultHttpControllerSelector(GlobalConfiguration.Configuration); ControllerContext = new HttpControllerContext(GlobalConfiguration.Configuration, HttpRouteData, HttpRequestMessage); }
public HttpControllerSelectorTracer(IHttpControllerSelector innerSelector, ITraceWriter traceWriter) { Contract.Assert(innerSelector != null); Contract.Assert(traceWriter != null); _innerSelector = innerSelector; _traceWriter = traceWriter; }
public ControllerActionSelector(HttpConfiguration conf, HttpRequestMessage req) { config = conf; request = req; routeData = config.Routes.GetRouteData(request); request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData; controllerSelector = new DefaultHttpControllerSelector(config); controllerContext = new HttpControllerContext(config, routeData, request); }
public WireUpApiStartable(HttpConfiguration config, IHttpControllerActivator controllerActivator, IHttpControllerSelector controllerSelector, ApiKeyHandler apiKeyHandler) { _config = config; _controllerActivator = controllerActivator; _controllerSelector = controllerSelector; _apiKeyHandler = apiKeyHandler; }
private IHttpControllerSelector GetControllerSelector() { if (MemoryCache.Default["ControllerSelector"] == null) { IHttpControllerSelector selector = this.Config.Services.GetHttpControllerSelector(); return(selector); } return(MemoryCache.Default["ControllerSelector"] as IHttpControllerSelector); }
private static void CreateControllerSelectorTracer(HttpConfiguration configuration, ITraceWriter traceWriter) { IHttpControllerSelector controllerSelector = configuration.Services.GetHttpControllerSelector(); if (controllerSelector != null && !(controllerSelector is HttpControllerSelectorTracer)) { HttpControllerSelectorTracer tracer = new HttpControllerSelectorTracer(controllerSelector, traceWriter); configuration.Services.Replace(typeof(IHttpControllerSelector), tracer); } }
private void GenerateRouteData() { matchedRoute = config.Routes.GetRouteData(request); if (matchedRoute != null) { request.Properties[HttpPropertyKeys.HttpRouteDataKey] = matchedRoute; controllerSelector = (IHttpControllerSelector)Activator.CreateInstance(ApiRouteAssert.ControllerSelectorType, config); controllerContext = new HttpControllerContext(config, matchedRoute, request); } }
/// <summary> /// Initializes a new instance of the <see cref="ResourceLinkParser"/> class. /// </summary> /// <param name="a_configuration"> /// The configuration to use to parse the URIs. /// </param> public ResourceLinkParser(HttpConfiguration a_configuration) { if (a_configuration == null) { throw new ArgumentNullException("a_configuration"); } m_configuration = a_configuration; m_actionSelector = m_configuration.Services.GetActionSelector(); m_controllerSelector = m_configuration.Services.GetHttpControllerSelector(); }
/// <summary> /// Initializes a new instance of the <see cref="ResourceLinkParser"/> class. /// </summary> /// <param name="configuration"> /// The configuration to use to parse the URIs. /// </param> public ResourceLinkParser(HttpConfiguration configuration) { if (configuration == null) { throw new ArgumentNullException("configuration"); } this.configuration = configuration; this.actionSelector = this.configuration.Services.GetActionSelector(); this.controllerSelector = this.configuration.Services.GetHttpControllerSelector(); }
public RouteMocker(HttpConfiguration config, HttpRequestMessage request) { _request = request; var routeData = config.Routes.GetRouteData(_request); _request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; _request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData; _controllerSelector = new DefaultHttpControllerSelector(config); _controllerContext = new HttpControllerContext(config, routeData, _request); }
static void Main(string[] args) { HttpConfiguration configuration = new HttpConfiguration(); IHttpControllerSelector controllerSelector = configuration.Services.GetHttpControllerSelector(); IDictionary <string, HttpControllerDescriptor> mappings = controllerSelector.GetControllerMapping(); Console.WriteLine("{0,-16}{1,-10}", "ControllerName", "TypeName"); foreach (var item in mappings) { Console.WriteLine("{0,-16}{1,-10}", item.Key, item.Value.ControllerType.Name); } }
public void Inner_Property_On_HttpControllerSelectorTracer_Returns_IHttpControllerSelector() { // Arrange IHttpControllerSelector expectedInner = new Mock <IHttpControllerSelector>().Object; HttpControllerSelectorTracer productUnderTest = new HttpControllerSelectorTracer(expectedInner, new TestTraceWriter()); // Act IHttpControllerSelector actualInner = productUnderTest.Inner; // Assert Assert.Same(expectedInner, actualInner); }
public void Decorator_GetInner_On_HttpControllerSelectorTracer_Returns_IHttpControllerSelector() { // Arrange IHttpControllerSelector expectedInner = new Mock <IHttpControllerSelector>().Object; HttpControllerSelectorTracer productUnderTest = new HttpControllerSelectorTracer(expectedInner, new TestTraceWriter()); // Act IHttpControllerSelector actualInner = Decorator.GetInner(productUnderTest as IHttpControllerSelector); // Assert Assert.Same(expectedInner, actualInner); }
private void GenerateRouteData() { matchedRoute = config.Routes.GetRouteData(request); if (matchedRoute != null) { request.Properties[HttpPropertyKeys.HttpRouteDataKey] = matchedRoute; controllerSelector = (IHttpControllerSelector)config.Services.GetService(typeof(IHttpControllerSelector)); controllerContext = new HttpControllerContext(config, matchedRoute, request); } }
public TestControllerBuilder(HttpRequestMessage request, HttpConfiguration httpConfiguration) { var routeData = request.Properties[HttpPropertyKeys.HttpRouteDataKey] as IHttpRouteData; controllerContext = new HttpControllerContext(httpConfiguration, routeData, request); IHttpControllerSelector controllerSelector = httpConfiguration.Services.GetHttpControllerSelector(); controlleDescriptor = controllerSelector.SelectController(request); controllerContext.ControllerDescriptor = controlleDescriptor; actionSelector = new ApiControllerActionSelector(); this.httpConfiguration = httpConfiguration; requestMessage = request; }
/// <summary> /// Initializes a new instance of the <see cref="ODataControllerSelector" /> class. /// </summary> /// <param name="routingConventions">The OData routing conventions to use for OData requests.</param> /// <param name="innerSelector">The inner controller selector to call.</param> public ODataControllerSelector(IEnumerable<IODataRoutingConvention> routingConventions, IHttpControllerSelector innerSelector) { if (routingConventions == null) { throw Error.ArgumentNull("routingConventions"); } if (innerSelector == null) { throw Error.ArgumentNull("innerSelector"); } _routingConventions = routingConventions; _innerSelector = innerSelector; }
/// <summary> /// Initializes a new instance of the <see cref="ODataControllerSelector" /> class. /// </summary> /// <param name="routingConventions">The OData routing conventions to use for OData requests.</param> /// <param name="innerSelector">The inner controller selector to call.</param> public ODataControllerSelector(IEnumerable <IODataRoutingConvention> routingConventions, IHttpControllerSelector innerSelector) { if (routingConventions == null) { throw Error.ArgumentNull("routingConventions"); } if (innerSelector == null) { throw Error.ArgumentNull("innerSelector"); } _routingConventions = routingConventions; _innerSelector = innerSelector; }
private static HttpRouteCollection MapHttpAttributeRoutesInternal(this HttpConfiguration configuration, HttpRouteBuilder routeBuilder) { HttpRouteCollection subRoutes = new HttpRouteCollection(); if (configuration == null) { throw Error.ArgumentNull("configuration"); } if (routeBuilder == null) { throw Error.ArgumentNull("routeBuilder"); } List <HttpRouteEntry> attributeRoutes = new List <HttpRouteEntry>(); IHttpControllerSelector controllerSelector = configuration.Services.GetHttpControllerSelector(); IDictionary <string, HttpControllerDescriptor> controllerMap = controllerSelector.GetControllerMapping(); if (controllerMap != null) { foreach (HttpControllerDescriptor controllerDescriptor in controllerMap.Values) { IEnumerable <HttpRouteEntry> controllerRoutes = CreateRouteEntries(controllerDescriptor); foreach (HttpRouteEntry route in controllerRoutes) { route.Route = routeBuilder.BuildHttpRoute(route.Template, route.Actions); } SetDefaultRouteNames(controllerRoutes, controllerDescriptor.ControllerName); attributeRoutes.AddRange(controllerRoutes); } attributeRoutes.Sort(); foreach (HttpRouteEntry attributeRoute in attributeRoutes) { IHttpRoute route = attributeRoute.Route; if (route != null) { subRoutes.Add(attributeRoute.Name, attributeRoute.Route); } } } return(subRoutes); }
private static void AddRouteEntries(SubRouteCollection collector, HttpConfiguration configuration, IInlineConstraintResolver constraintResolver) { Contract.Assert(configuration != null); IHttpControllerSelector controllerSelector = configuration.Services.GetHttpControllerSelector(); IDictionary <string, HttpControllerDescriptor> controllerMap = controllerSelector.GetControllerMapping(); if (controllerMap != null) { foreach (HttpControllerDescriptor controllerDescriptor in controllerMap.Values) { AddRouteEntries(collector, controllerDescriptor, constraintResolver); } } }
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { IHttpRouteData routeData = request.GetRouteData(); IHttpControllerSelector ControllerSelector = mConfiguration.Services.GetHttpControllerSelector(); HttpControllerDescriptor httpControllerDescriptor = ControllerSelector.SelectController(request); IHttpController httpController = httpControllerDescriptor.CreateController(request); request.Method = new HttpMethod(mVerbChange); // Create context HttpControllerContext controllerContext = new HttpControllerContext(mConfiguration, routeData, request); controllerContext.Controller = httpController; controllerContext.ControllerDescriptor = httpControllerDescriptor; return(httpController.ExecuteAsync(controllerContext, cancellationToken)); }
private Collection <ApiDescription> InitializeApiDescriptions() { Collection <ApiDescription> apiDescriptions = new Collection <ApiDescription>(); IHttpControllerSelector controllerSelector = _config.Services.GetHttpControllerSelector(); IDictionary <string, HttpControllerDescriptor> controllerMappings = controllerSelector.GetControllerMapping(); if (controllerMappings != null) { ApiDescriptionComparer descriptionComparer = new ApiDescriptionComparer(); foreach (IHttpRoute route in FlattenRoutes(_config.Routes)) { CandidateAction[] directRouteCandidates = route.GetDirectRouteCandidates(); HttpControllerDescriptor directRouteController = GetDirectRouteController( directRouteCandidates ); Collection <ApiDescription> descriptionsFromRoute = (directRouteController != null && directRouteCandidates != null) ? ExploreDirectRoute( directRouteController, directRouteCandidates, route ) : ExploreRouteControllers(controllerMappings, route); // Remove ApiDescription that will lead to ambiguous action matching. // E.g. a controller with Post() and PostComment(). When the route template is {controller}, it produces POST /controller and POST /controller. descriptionsFromRoute = RemoveInvalidApiDescriptions(descriptionsFromRoute); foreach (ApiDescription description in descriptionsFromRoute) { // Do not add the description if the previous route has a matching description with the same HTTP method and relative path. // E.g. having two routes with the templates "api/Values/{id}" and "api/{controller}/{id}" can potentially produce the same // relative path "api/Values/{id}" but only the first one matters. if (!apiDescriptions.Contains(description, descriptionComparer)) { apiDescriptions.Add(description); } } } } return(apiDescriptions); }
public HeaderVersionControllerSelector(IHttpControllerSelector previousSelector, HttpConfiguration config) { _config = config; _previousSelector = previousSelector; var types = from t in Assembly.GetExecutingAssembly().GetTypes() where typeof(ApiController).IsAssignableFrom(t) && t.Namespace != null && t.Namespace.StartsWith(ApiNamespace, StringComparison.CurrentCultureIgnoreCase) select new { SubNamespace = t.Namespace.Substring(ApiNamespace.Length), Type = t }; foreach (var type in types) { var subNamespaces = type.SubNamespace.Split('.') as IEnumerable <string>; if (subNamespaces.ElementAt(0).IsNullOrEmpty()) { subNamespaces = subNamespaces.Skip(1); } var lastNamespace = subNamespaces.LastOrDefault(); if (string.Compare(lastNamespace.SubstringWithoutError(0, 1), "v", true) == 0) { lastNamespace = lastNamespace.Substring(1); } int version; var initialNamespace = lastNamespace; if (!int.TryParse(lastNamespace, out version)) { version = MaxVersion; } else { initialNamespace = subNamespaces.Reverse().Skip(1).Reverse().JoinString("."); } _namespaceLocator.Add(initialNamespace, type.Type.Name, version, new HttpControllerDescriptor(_config, type.Type.Name, type.Type)); } }
/// <summary> /// Initializes a new instance of the <see cref="AttributeRoutingConvention"/> class. /// </summary> /// <param name="model">The <see cref="IEdmModel"/> to be used for parsing the route templates.</param> /// <param name="configuration">The <see cref="HttpConfiguration"/> to use for figuring out all the controllers to /// look for a match.</param> /// <param name="pathTemplateHandler">The path template handler to be used for parsing the path templates.</param> public AttributeRoutingConvention(IEdmModel model, HttpConfiguration configuration, IODataPathTemplateHandler pathTemplateHandler) : this(model, pathTemplateHandler) { if (configuration == null) { throw Error.ArgumentNull("configuration"); } Action <HttpConfiguration> oldInitializer = configuration.Initializer; configuration.Initializer = (config) => { oldInitializer(config); IHttpControllerSelector controllerSelector = config.Services.GetHttpControllerSelector(); _attributeMappingsFunc = () => BuildAttributeMappings(controllerSelector.GetControllerMapping().Values); }; }
private Collection <ApiDescription> InitializeApiDescriptions() { Collection <ApiDescription> apiDescriptions = new Collection <ApiDescription>(); IHttpControllerSelector controllerSelector = _config.Services.GetHttpControllerSelector(); IDictionary <string, HttpControllerDescriptor> controllerMappings = controllerSelector.GetControllerMapping(); if (controllerMappings != null) { foreach (var route in _config.Routes) { ExploreRouteControllers(controllerMappings, route, apiDescriptions); } // remove ApiDescription that will lead to ambiguous action matching. E.g. a controller with Post() and PostComment(). When the route template is {controller}, it produces POST /controller and POST /controller. apiDescriptions = RemoveInvalidApiDescriptions(apiDescriptions); } return(apiDescriptions); }
/// <summary> /// Maps the attribute-defined routes for the application. /// </summary> /// <param name="configuration">The server configuration.</param> /// <param name="routeBuilder">The <see cref="HttpRouteBuilder"/> to use for generating attribute routes.</param> public static void MapHttpAttributeRoutes(this HttpConfiguration configuration, HttpRouteBuilder routeBuilder) { if (configuration == null) { throw Error.ArgumentNull("configuration"); } if (routeBuilder == null) { throw Error.ArgumentNull("routeBuilder"); } List <HttpRouteEntry> attributeRoutes = new List <HttpRouteEntry>(); IHttpControllerSelector controllerSelector = configuration.Services.GetHttpControllerSelector(); IDictionary <string, HttpControllerDescriptor> controllerMapping = controllerSelector.GetControllerMapping(); if (controllerMapping != null) { foreach (HttpControllerDescriptor controllerDescriptor in controllerMapping.Values) { Collection <RoutePrefixAttribute> routePrefixes = controllerDescriptor.GetCustomAttributes <RoutePrefixAttribute>(inherit: false); IHttpActionSelector actionSelector = controllerDescriptor.Configuration.Services.GetActionSelector(); ILookup <string, HttpActionDescriptor> actionMapping = actionSelector.GetActionMapping(controllerDescriptor); if (actionMapping != null) { foreach (IGrouping <string, HttpActionDescriptor> actionGrouping in actionMapping) { string controllerName = controllerDescriptor.ControllerName; attributeRoutes.AddRange(CreateAttributeRoutes(routeBuilder, controllerName, routePrefixes, actionGrouping)); } } } attributeRoutes.Sort(); foreach (HttpRouteEntry attributeRoute in attributeRoutes) { configuration.Routes.Add(attributeRoute.Name, attributeRoute.Route); } } }
public override RequestAnalysisResult GetRequestAnalysis(RequestAnalysisContext analysisContext) { HttpRequestMessage request = analysisContext.RequestMessage; HttpConfiguration httpConfiguration = request.GetConfiguration(); IHttpRouteData httpRouteData = httpConfiguration.Routes.GetRouteData(request); request.SetRouteData(httpRouteData); //IAssembliesResolver assembliesResolver= httpConfiguration.Services.GetAssembliesResolver(); //IHttpControllerTypeResolver controllerTypeResolver = httpConfiguration.Services.GetHttpControllerTypeResolver(); //ICollection<Type> controllerTypes= controllerTypeResolver.GetControllerTypes(assembliesResolver); IHttpControllerSelector controllerSelector = httpConfiguration.Services.GetHttpControllerSelector(); HttpControllerDescriptor controllerDescriptor = controllerSelector.SelectController(request); HttpControllerContext controllerContext = new HttpControllerContext(httpConfiguration, httpRouteData, request); controllerContext.ControllerDescriptor = controllerDescriptor; IHttpActionSelector actionSelector = httpConfiguration.Services.GetActionSelector(); HttpActionDescriptor actionDescriptor = actionSelector.SelectAction(controllerContext); RequestAnalysisResult analysisResult = new RequestAnalysisResult(); analysisResult.Url = request.RequestUri.ToString(); analysisResult.SupportedHttpMethods = actionDescriptor.SupportedHttpMethods.Select(method => method.Method).ToArray(); analysisResult.Parameters = actionDescriptor.GetParameters().Select(parameter => parameter.ParameterName).ToArray(); analysisResult.ActionName = actionDescriptor.ActionName; analysisResult.ControllerName = actionDescriptor.ControllerDescriptor.ControllerName; analysisResult.Values = httpRouteData.Values; analysisResult.DataTokens = httpRouteData.Route.DataTokens; analysisResult.Mode = Mode; string path = new DirectoryInfo(string.Format(@"{0}{1}", AppDomain.CurrentDomain.BaseDirectory, LookupPrefix)).FullName; analysisResult.FilePath = LookupFilePath(path, analysisResult.ControllerName); return(analysisResult); }
/// <summary> /// Initializes a new instance of the <see cref="AttributeRoutingConvention"/> class. /// </summary> /// <param name="routeName">The name of the route.</param> /// <param name="configuration">The <see cref="HttpConfiguration"/> to use for figuring out all the controllers to /// look for a match.</param> /// <param name="pathTemplateHandler">The path template handler to be used for parsing the path templates.</param> /// <remarks>This signature uses types that are AspNet-specific.</remarks> public AttributeRoutingConvention(string routeName, HttpConfiguration configuration, IODataPathTemplateHandler pathTemplateHandler) : this(routeName) { if (configuration == null) { throw Error.ArgumentNull("configuration"); } if (pathTemplateHandler == null) { throw Error.ArgumentNull("pathTemplateHandler"); } ODataPathTemplateHandler = pathTemplateHandler; // if settings is not on local, use the global configuration settings. IODataPathHandler pathHandler = pathTemplateHandler as IODataPathHandler; if (pathHandler != null && pathHandler.UrlKeyDelimiter == null) { ODataUrlKeyDelimiter urlKeyDelimiter = configuration.GetUrlKeyDelimiter(); pathHandler.UrlKeyDelimiter = urlKeyDelimiter; } Action <HttpConfiguration> oldInitializer = configuration.Initializer; bool initialized = false; configuration.Initializer = (config) => { if (!initialized) { initialized = true; oldInitializer(config); IHttpControllerSelector controllerSelector = config.Services.GetHttpControllerSelector(); _attributeMappings = BuildAttributeMappings(controllerSelector.GetControllerMapping().Values); } }; }
protected override void UpdateConfiguration(WebRouteConfiguration configuration) { var controllers = new[] { typeof(BaseAddressFactoryModelsController) }; configuration.AddControllers(controllers); var model = GetEdmModel(configuration); configuration.Routes.Clear(); configuration.MapODataServiceRoute("odata", "odata", model); configuration.EnsureInitialized(); ServicesContainer services = configuration.Services; IHttpControllerSelector controllerSelector = services.GetHttpControllerSelector(); var controllerMappings = controllerSelector.GetControllerMapping().Values; foreach (var c in controllerMappings) { var odataFormatter = c.Configuration.Formatters.OfType <ODataMediaTypeFormatter>(); foreach (var f in odataFormatter) { f.BaseAddressFactory = (m) => new Uri("http://foo.bar/", UriKind.Absolute); } } }
public GenericControllerSelector(HttpConfiguration config, IEnumerable <EntitySetConfiguration> entities, IHttpControllerSelector innerSelector) { _controllerMappings = GenerateMappings(config, entities); _InnerSelector = innerSelector; }
internal RaygunWebApiControllerSelector(IHttpControllerSelector concreteSelector, IRaygunWebApiClientProvider clientCreator) { _concreteSelector = concreteSelector; _clientCreator = clientCreator; }
private static void AddRouteEntries( SubRouteCollection collector, HttpConfiguration configuration, IInlineConstraintResolver constraintResolver, IDirectRouteProvider directRouteProvider) { Contract.Assert(configuration != null); Contract.Assert(directRouteProvider != null); IHttpControllerSelector controllerSelector = configuration.Services.GetHttpControllerSelector(); IDictionary <string, HttpControllerDescriptor> controllerMap = controllerSelector.GetControllerMapping(); if (controllerMap != null) { foreach (HttpControllerDescriptor controllerDescriptor in controllerMap.Values) { IHttpActionSelector actionSelector = controllerDescriptor.Configuration.Services.GetActionSelector(); ILookup <string, HttpActionDescriptor> actionsByName = actionSelector.GetActionMapping(controllerDescriptor); if (actionsByName == null) { continue; } List <HttpActionDescriptor> actions = actionsByName.SelectMany(g => g).ToList(); IReadOnlyCollection <RouteEntry> newEntries = directRouteProvider.GetDirectRoutes(controllerDescriptor, actions, constraintResolver); if (newEntries == null) { throw Error.InvalidOperation( SRResources.TypeMethodMustNotReturnNull, typeof(IDirectRouteProvider).Name, "GetDirectRoutes"); } foreach (RouteEntry entry in newEntries) { if (entry == null) { throw Error.InvalidOperation( SRResources.TypeMethodMustNotReturnNull, typeof(IDirectRouteProvider).Name, "GetDirectRoutes"); } DirectRouteBuilder.ValidateRouteEntry(entry); // We need to mark each action as only reachable by direct routes so that traditional routes // don't accidentally hit them. HttpControllerDescriptor routeControllerDescriptor = entry.Route.GetTargetControllerDescriptor(); if (routeControllerDescriptor == null) { HttpActionDescriptor[] actionDescriptors = entry.Route.GetTargetActionDescriptors(); foreach (var actionDescriptor in actionDescriptors) { actionDescriptor.SetIsAttributeRouted(true); } } else { routeControllerDescriptor.SetIsAttributeRouted(true); } } collector.AddRange(newEntries); } } }
public HttpControllerSelectorTracer(IHttpControllerSelector innerSelector, ITraceWriter traceWriter) { _innerSelector = innerSelector; _traceWriter = traceWriter; }
public DynamicControllerSelector(HttpConfiguration configuration, IHttpControllerSelector originalSelector) : base(configuration) { this._configuration = configuration; this._originalControllerSelector = originalSelector; }
public InspectControllerSelector(IHttpControllerSelector innerSelector) { _innerSelector = innerSelector; }
public DebugControllerSelector(IHttpControllerSelector httpControllerSelector) { // TODO: Complete member initialization this.httpControllerSelector = httpControllerSelector; }
private void GenerateRouteData() { matchedRoute = config.Routes.GetRouteData(request); if (matchedRoute != null) { request.Properties[HttpPropertyKeys.HttpRouteDataKey] = matchedRoute; controllerSelector = (IHttpControllerSelector) Activator.CreateInstance(ApiRouteAssert.ControllerSelectorType, config); controllerContext = new HttpControllerContext(config, matchedRoute, request); } }
public ControllerSelectorWrapper(IHttpControllerSelector inner) { this.inner = inner; }
public NamespaceHttpControllerSelector(HttpConfiguration configuration) { _configuration = configuration; _defaultSelector=new DefaultHttpControllerSelector(configuration); }
public SuperscribeControllerSelectorAdapter(IHttpControllerSelector baseSelector) { this.baseSelector = baseSelector; }
public ApiRouteTester(HttpConfiguration conf, HttpRequestMessage req) { _config = conf; _request = req; _routeData = _config.Routes.GetRouteData(_request); _request.Properties[HttpPropertyKeys.HttpRouteDataKey] = _routeData; _controllerSelector = new DefaultHttpControllerSelector(_config); _controllerContext = new HttpControllerContext(_config, _routeData, _request); }
private void GenerateRouteData() { matchedRoute = config.Routes.GetRouteData(request); if (matchedRoute != null) { request.Properties[HttpPropertyKeys.HttpRouteDataKey] = matchedRoute; controllerSelector = new DefaultHttpControllerSelector(config); controllerContext = new HttpControllerContext(config, matchedRoute, request); } }
private EntityRepositoryControllerSelector(ServicesContainer servicesContainer, ODataServerConfigurer oDataServerConfigurer) { _fallbackControllerSelector = servicesContainer.GetHttpControllerSelector(); _managedControllers = new Dictionary<string, HttpControllerDescriptor>(ODataServerConfigurer.InitialEntitySetCapacity, StringComparer.OrdinalIgnoreCase); }
public InspectControllerSelector(IHttpControllerSelector delegating) { _delegating = delegating; }