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 DebugControllerSelector(IHttpControllerSelector httpControllerSelector)
{
// TODO: Complete member initialization
this.httpControllerSelector = httpControllerSelector;
}
public HttpControllerSelectorTracer(IHttpControllerSelector innerSelector, ITraceWriter traceWriter)
{
_innerSelector = innerSelector;
_traceWriter = traceWriter;
}
public InspectControllerSelector(IHttpControllerSelector innerSelector)
{
_innerSelector = innerSelector;
}
public NamespaceHttpControllerSelector(HttpConfiguration configuration)
{
_configuration = configuration;
_defaultSelector=new DefaultHttpControllerSelector(configuration);
}
internal RaygunWebApiControllerSelector(IHttpControllerSelector concreteSelector, IRaygunWebApiClientProvider clientCreator)
{
_concreteSelector = concreteSelector;
_clientCreator = clientCreator;
}
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;
}
