public ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { return new List<Type> { typeof (FooBarBazQuxController) }; }
public ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { return this.httpControllerTypeResolvers .SelectMany(a => a.GetControllerTypes(assembliesResolver)) .Distinct() .ToList(); }
static AssembliesResolver() { var resolver = new ResourceAssemblyResolver(); resourceAssemblyResolver = resolver; AppDomain.CurrentDomain.AssemblyResolve += (s, e) => resolver.OnAssemblyResolve(e); }
public ICollection<Type> GetControllerTypes(IAssembliesResolver _) { var httpControllerType = typeof(IHttpController); return typeof(WebApiConfig) .Assembly .GetTypes() .Where(t => t.IsClass && !t.IsAbstract && httpControllerType.IsAssignableFrom(t)) .ToList(); }
/// <summary> /// Returns a list of handlers available for the application. /// </summary> /// <param name="assembliesResolver"> /// The <see cref="IAssembliesResolver"/>. /// </param> /// <returns> /// An <see cref="ICollection{Type}"/> of handlers. /// </returns> public ICollection<Type> GetCommandHandlerTypes(IAssembliesResolver assembliesResolver) { if (assembliesResolver == null) { throw Error.ArgumentNull("assembliesResolver"); } return this.GetHandlerTypes(assembliesResolver); }
/// <summary> /// Returns a list of handlers available for the application. /// </summary> /// <param name="assembliesResolver"> /// The <see cref="IAssembliesResolver"/>. /// </param> /// <returns> /// An <see cref="ICollection{Type}"/> of handlers. /// </returns> public IEnumerable<Type> GetEventHandlerTypes(IAssembliesResolver assembliesResolver) { if (assembliesResolver == null) { throw Error.ArgumentNull("assembliesResolver"); } return this.GetHandlerTypes(assembliesResolver); }
public override ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { var list = base.GetControllerTypes(assembliesResolver).ToList(); var dynamicApis = ApiConfig.DynamicApiAssembly.GetTypes(); list.AddRange(dynamicApis); //Dynamic de sadece api controller olur. return list; }
public virtual ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { if (assembliesResolver == null) { throw new ArgumentNullException("assembliesResolver"); } // Go through all assemblies referenced by the application and search for types matching a predicate ICollection<Assembly> assemblies = assembliesResolver.GetAssemblies(); return (_controllerTypes ?? (_controllerTypes = GetControllerTypesInternal(assemblies))).ToList(); }
public HttpControllerTypeCache(HttpConfiguration configuration) { if (configuration == null) { throw Error.ArgumentNull("configuration"); } _configuration = configuration; _assembliesResolver = _configuration.ServiceResolver.GetAssembliesResolver(); _controllersResolver = _configuration.ServiceResolver.GetHttpControllerTypeResolver(); _cache = InitializeCache(); }
private static HttpSelfHostConfiguration CrearConfiguracion(String baseAddress, IAssembliesResolver assemblyResovler) { var config = new HttpSelfHostConfiguration(baseAddress); config.Services.Replace(typeof(IAssembliesResolver), assemblyResovler); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: ConfigurationManager.AppSettings["routeTemplate"], defaults: new { id = RouteParameter.Optional } ); return config; }
internal AggregationBinder(ODataQuerySettings settings, IAssembliesResolver assembliesResolver, Type elementType, IEdmModel model, TransformationNode transformation) : base(model, assembliesResolver, settings) { Contract.Assert(elementType != null); Contract.Assert(transformation != null); _elementType = elementType; _transformation = transformation; this._lambdaParameter = Expression.Parameter(this._elementType, "$it"); switch (transformation.Kind) { case TransformationNodeKind.Aggregate: var aggregateClause = this._transformation as AggregateTransformationNode; _aggregateExpressions = aggregateClause.Expressions; ResultClrType = AggregationDynamicTypeProvider.GetResultType<DynamicTypeWrapper>(_model, null, _aggregateExpressions); break; case TransformationNodeKind.GroupBy: var groupByClause = this._transformation as GroupByTransformationNode; _groupingProperties = groupByClause.GroupingProperties; if (groupByClause.ChildTransformations != null) { if (groupByClause.ChildTransformations.Kind == TransformationNodeKind.Aggregate) { _aggregateExpressions = ((AggregateTransformationNode)groupByClause.ChildTransformations).Expressions; } else { throw new NotImplementedException(); } } _groupByClrType = AggregationDynamicTypeProvider.GetResultType<DynamicTypeWrapper>(_model, _groupingProperties, null); ResultClrType = AggregationDynamicTypeProvider.GetResultType<DynamicTypeWrapper>(_model, _groupingProperties, _aggregateExpressions); break; default: throw new NotSupportedException(String.Format(CultureInfo.InvariantCulture, SRResources.NotSupportedTransformationKind, transformation.Kind)); } _groupByClrType = _groupByClrType ?? typeof(DynamicTypeWrapper); }
private static Dictionary <Type, List <Type> > BuildDerivedTypesMapping(IAssembliesResolver assemblyResolver) { IEnumerable <Type> allTypes = TypeHelper.GetLoadedTypes(assemblyResolver).Where(t => t.IsVisible && t.IsClass && t != typeof(object)); Dictionary <Type, List <Type> > allTypeMapping = allTypes.ToDictionary(k => k, k => new List <Type>()); foreach (Type type in allTypes) { List <Type> derivedTypes; if (type.BaseType != null && allTypeMapping.TryGetValue(type.BaseType, out derivedTypes)) { derivedTypes.Add(type); } } return(allTypeMapping); }
// Trace beginning and end of GetControllerTypes() invocations. Error tracing should never occur since base // implementation swallows all exceptions. public override ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { ICollection <Type> result = null; _traceWriter.TraceBeginEnd(request: null, category: TraceCategories.ControllersCategory, level: TraceLevel.Debug, operatorName: _innerTypeName, operationName: "GetControllerTypes", beginTrace: null, execute: () => { result = _innerResolver.GetControllerTypes(assembliesResolver); }, endTrace: null, errorTrace: null); return(result); }
public override ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { var controllerTypes = base.GetControllerTypes(assembliesResolver); var dynamicControllerTypes = _dynamicAssembliesResolver .GetDynamicAssemblies() .SelectMany(x => x.GetTypes()) .Where(x => IsControllerTypePredicate(x)); foreach (var dynamicControllerType in dynamicControllerTypes) { controllerTypes.Add(dynamicControllerType); } return controllerTypes; }
internal AggregationBinder(ODataQuerySettings settings, IAssembliesResolver assembliesResolver, Type elementType, IEdmModel model, TransformationNode transformation) : base(model, assembliesResolver, settings) { Contract.Assert(elementType != null); Contract.Assert(transformation != null); this._elementType = elementType; this._transformation = transformation; this._lambdaParameter = Expression.Parameter(this._elementType, "$it"); switch (transformation.Kind) { case TransformationNodeKind.Aggregate: var aggregateClause = this._transformation as AggregateTransformationNode; this._aggregateExpressions = this.FixCustomMethodReturnTypes(aggregateClause.Expressions); this.ResultClrType = typeof(NoGroupByAggregationWrapper); break; case TransformationNodeKind.GroupBy: var groupByClause = this._transformation as GroupByTransformationNode; this._groupingProperties = groupByClause.GroupingProperties; if (groupByClause.ChildTransformations != null) { if (groupByClause.ChildTransformations.Kind == TransformationNodeKind.Aggregate) { var aggregationNode = (AggregateTransformationNode)groupByClause.ChildTransformations; this._aggregateExpressions = this.FixCustomMethodReturnTypes(aggregationNode.Expressions); } else { throw new NotImplementedException(); } } this._groupByClrType = typeof(GroupByWrapper); this.ResultClrType = typeof(AggregationWrapper); break; default: throw new NotSupportedException(String.Format(CultureInfo.InvariantCulture, SRResources.NotSupportedTransformationKind, transformation.Kind)); } this._groupByClrType = this._groupByClrType ?? typeof(NoGroupByWrapper); }
private ConcurrentDictionary <string, HttpControllerDescriptor> InitializeControllerInfoCache() { var result = new ConcurrentDictionary <string, HttpControllerDescriptor>(StringComparer.OrdinalIgnoreCase); var duplicateControllers = new HashSet <string>(); IAssembliesResolver assembliesResolver = _configuration.Services.GetAssembliesResolver(); IHttpControllerTypeResolver controllersResolver = _configuration.Services.GetHttpControllerTypeResolver(); ICollection <Type> controllerTypes = controllersResolver.GetControllerTypes(assembliesResolver); var groupedByName = controllerTypes.GroupBy( t => t.Name.Substring(0, t.Name.Length - DefaultHttpControllerSelector.ControllerSuffix.Length), StringComparer.OrdinalIgnoreCase); var _controllerTypeCacheCache = groupedByName.ToDictionary( g => g.Key, g => g.ToLookup(t => t.Namespace ?? String.Empty, StringComparer.OrdinalIgnoreCase), StringComparer.OrdinalIgnoreCase); Dictionary <string, ILookup <string, Type> > controllerTypeGroups = _controllerTypeCacheCache; foreach (KeyValuePair <string, ILookup <string, Type> > controllerTypeGroup in controllerTypeGroups) { string controllerName = controllerTypeGroup.Key; foreach (IGrouping <string, Type> controllerTypesGroupedByNs in controllerTypeGroup.Value) { foreach (Type controllerType in controllerTypesGroupedByNs) { if (result.Keys.Contains(controllerName)) { duplicateControllers.Add(controllerName); break; } else { result.TryAdd(controllerName, new HttpControllerDescriptor(_configuration, controllerName, controllerType)); } } } } foreach (string duplicateController in duplicateControllers) { HttpControllerDescriptor descriptor; result.TryRemove(duplicateController, out descriptor); } return(result); }
/// <summary> /// Initializes a new instance of the <see cref="ODataQueryOptions"/> class based on the incoming request and some metadata information from /// the <see cref="ODataQueryContext"/>. /// </summary> /// <param name="context">The <see cref="ODataQueryContext"/> which contains the <see cref="IEdmModel"/> and some type information.</param> /// <param name="request">The incoming request message.</param> public ODataQueryOptions(ODataQueryContext context, HttpRequestMessage request) { if (context == null) { throw Error.ArgumentNull("context"); } if (request == null) { throw Error.ArgumentNull("request"); } if (request.GetConfiguration() != null) { _assembliesResolver = request.GetConfiguration().Services.GetAssembliesResolver(); } // fallback to the default assemblies resolver if none available. _assembliesResolver = _assembliesResolver ?? new DefaultAssembliesResolver(); // remember the context and request Context = context; Request = request; // Parse the query from request Uri RawValues = new ODataRawQueryOptions(); IDictionary <string, string> queryParameters = request.GetQueryNameValuePairs().ToDictionary(p => p.Key, p => p.Value); _queryOptionParser = new ODataQueryOptionParser( context.Model, context.ElementType, context.NavigationSource, queryParameters); HttpConfiguration configuration = Request.GetConfiguration(); if (configuration != null) { ODataUriResolverSetttings resolverSettings = configuration.GetResolverSettings(); _queryOptionParser.Resolver = resolverSettings.CreateResolver(context.Model); } BuildQueryOptions(queryParameters); Validator = new ODataQueryValidator(); }
/// <summary> /// 初始化字典 /// </summary> /// <returns></returns> private Dictionary <string, HttpControllerDescriptor> InitializeControllerDictionary() { var dictionary = new Dictionary <string, HttpControllerDescriptor>(StringComparer.OrdinalIgnoreCase); // Create a lookup table where key is "namespace.controller". The value of "namespace" is the last // segment of the full namespace. For example: // MyApplication.Controllers.V1.ProductsController => "V1.Products" IAssembliesResolver assembliesResolver = _configuration.Services.GetAssembliesResolver(); IHttpControllerTypeResolver controllersResolver = _configuration.Services.GetHttpControllerTypeResolver(); ICollection <Type> controllerTypes = controllersResolver.GetControllerTypes(assembliesResolver); foreach (Type t in controllerTypes) { if (t.Namespace != null) { var segments = t.Namespace.Split(Type.Delimiter); // For the dictionary key, strip "Controller" from the end of the type name. // This matches the behavior of DefaultHttpControllerSelector. var controllerName = t.Name.Remove(t.Name.Length - DefaultHttpControllerSelector.ControllerSuffix.Length); string version = segments[segments.Length - 1]; var key = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", version, controllerName); if (version == "Controllers") { key = String.Format(CultureInfo.InvariantCulture, "{0}", controllerName); } // Check for duplicate keys. if (dictionary.Keys.Contains(key)) { _duplicates.Add(key); } else { dictionary[key] = new HttpControllerDescriptor(_configuration, t.Name, t); } } } // Remove any duplicates from the dictionary, because these create ambiguous matches. // For example, "Foo.V1.ProductsController" and "Bar.V1.ProductsController" both map to "v1.products". foreach (string s in _duplicates) { dictionary.Remove(s); } return(dictionary); }
public SelectExpandBinder(ODataQuerySettings settings, IAssembliesResolver assembliesResolver, SelectExpandQueryOption selectExpandQuery) { Contract.Assert(settings != null); Contract.Assert(assembliesResolver != null); Contract.Assert(selectExpandQuery != null); Contract.Assert(selectExpandQuery.Context != null); Contract.Assert(selectExpandQuery.Context.Model != null); Contract.Assert(settings.HandleNullPropagation != HandleNullPropagationOption.Default); _selectExpandQuery = selectExpandQuery; _context = selectExpandQuery.Context; _model = _context.Model; _modelID = ModelContainer.GetModelID(_model); _settings = settings; _assembliesResolver = assembliesResolver; }
/// <summary> /// Initializes a new <see cref="OwinRestService"/>. /// </summary> /// <param name="kernel">Ninject kernel instance.</param> /// <param name="logService">Service used for logging.</param> /// <param name="configStore">Configuration storage instance.</param> /// <param name="antFactory">Factory used for instantiating <see cref="IAnt"/>.</param> /// <param name="assembliesResolverFactory">Factory used for instantiating <see cref="IAssembliesResolver"/>.</param> public OwinRestService( IKernel kernel, ILog logService, IConfigStore configStore, IAntFactory antFactory, IAssembliesResolverFactory assembliesResolverFactory) { hostKernel = new ChildKernel(kernel); this.logService = logService; this.configStore = configStore; this.antFactory = antFactory; assembliesResolver = assembliesResolverFactory .CreateNew(typeof(OwinRestService).Assembly); }
public virtual ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { if (assembliesResolver == null) { throw Error.ArgumentNull("assembliesResolver"); } List <Type> result = new List <Type>(); // Go through all assemblies referenced by the application and search for types matching a predicate ICollection <Assembly> assemblies = assembliesResolver.GetAssemblies(); foreach (Assembly assembly in assemblies) { Type[] exportedTypes = null; if (assembly == null || assembly.IsDynamic) { // can't call GetTypes on a null (or dynamic?) assembly continue; } try { exportedTypes = _getTypesFunc(assembly); } catch (ReflectionTypeLoadException ex) { exportedTypes = ex.Types; } catch { // We deliberately ignore all exceptions when building the cache. If // a controller type is not found then we will respond later with a 404. // However, until then we don't know whether an exception at all will // have an impact on finding a controller. continue; } if (exportedTypes != null) { result.AddRange(exportedTypes.Where(x => TypeIsVisible(x) && IsControllerTypePredicate(x))); } } return(result); }
public override ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { List <Type> list = new List <Type>(); var controllerType = typeof(System.Web.Http.Controllers.IHttpController); if (Directory.Exists(contollerPath)) { foreach (var dllFile in Directory.GetFiles(contollerPath, "*.dll")) { Assembly assembly = Assembly.LoadFrom(dllFile); var types = assembly.GetExportedTypes(); list.AddRange(types.Where(i => controllerType.IsAssignableFrom(i)).ToList()); } } return(list); }
public virtual ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { if (assembliesResolver == null) { throw Error.ArgumentNull("assembliesResolver"); } List<Type> result = new List<Type>(); // Go through all assemblies referenced by the application and search for types matching a predicate ICollection<Assembly> assemblies = assembliesResolver.GetAssemblies(); foreach (Assembly assembly in assemblies) { Type[] exportedTypes = null; if (assembly == null || assembly.IsDynamic) { // can't call GetExportedTypes on a dynamic assembly continue; } try { exportedTypes = assembly.GetExportedTypes(); } catch (ReflectionTypeLoadException ex) { exportedTypes = ex.Types; } catch { // We deliberately ignore all exceptions when building the cache. If // a controller type is not found then we will respond later with a 404. // However, until then we don't know whether an exception at all will // have an impact on finding a controller. continue; } if (exportedTypes != null) { result.AddRange(exportedTypes.Where(x => IsControllerTypePredicate(x))); } } return result; }
public override ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { var ret = base.GetControllerTypes(assembliesResolver); var parts = _container.Catalog.Parts.Where( partDef => partDef.ExportDefinitions.Any( p => string.Equals(p.ContractName, ContractNames.ApiController, StringComparison.Ordinal))); foreach (var composablePartDefinition in parts) { // TODO this isn't fantastic as it makes a lot of assumption about the CPD var lazyType = ReflectionModelServices.GetPartType(composablePartDefinition); ret.Add(lazyType.Value); } return(ret); }
public override HttpControllerDescriptor SelectController(HttpRequestMessage request) { var controllerName = base.GetControllerName(request); if (controllerName.Contains("_")) { IAssembliesResolver assembliesResolver = _configuration.Services.GetAssembliesResolver(); IHttpControllerTypeResolver httpControllerTypeResolver = this._configuration.Services.GetHttpControllerTypeResolver(); ICollection <Type> controllerTypes = httpControllerTypeResolver.GetControllerTypes(assembliesResolver); controllerName = controllerName.Replace("_", ""); var matchedController = controllerTypes.FirstOrDefault(i => i.Name.ToLower() == controllerName.ToLower() + "controller"); return(new HttpControllerDescriptor(_configuration, controllerName, matchedController)); } return(base.SelectController(request)); }
public override ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { var ret = base.GetControllerTypes(assembliesResolver); var parts = _container.Catalog.Parts.Where( partDef => partDef.ExportDefinitions.Any( p => string.Equals(p.ContractName, ContractNames.ApiController, StringComparison.Ordinal))); foreach (var composablePartDefinition in parts) { // TODO this isn't fantastic as it makes a lot of assumption about the CPD var lazyType = ReflectionModelServices.GetPartType(composablePartDefinition); ret.Add(lazyType.Value); } return ret; }
private Dictionary <string, Dictionary <string, HttpControllerDescriptor> > InitializeCache() { IAssembliesResolver assembliesResolver = this._configuration.Services.GetAssembliesResolver(); IHttpControllerTypeResolver httpControllerTypeResolver = this._configuration.Services.GetHttpControllerTypeResolver(); ICollection <Type> controllerTypes = httpControllerTypeResolver.GetControllerTypes(assembliesResolver); IEnumerable <IGrouping <string, Type> > source = controllerTypes.GroupBy(t => t.Name.EndsWith(NamespaceControllerSelector.ControllerSuffix, StringComparison.OrdinalIgnoreCase) ? t.Name.Substring(0, t.Name.Length - NamespaceControllerSelector.ControllerSuffix.Length) : t.Name, StringComparer.OrdinalIgnoreCase); return(source.ToDictionary(g => g.Key, g => g.ToDictionary( t => t.Namespace ?? string.Empty, t => new HttpControllerDescriptor(this._configuration, g.Key, t), StringComparer.OrdinalIgnoreCase), StringComparer.OrdinalIgnoreCase)); }
internal AggregationBinder(ODataQuerySettings settings, IAssembliesResolver assembliesResolver, Type elementType, IEdmModel model, TransformationNode transformation) : base(model, assembliesResolver, settings) { Contract.Assert(elementType != null); Contract.Assert(transformation != null); _elementType = elementType; _transformation = transformation; this._lambdaParameter = Expression.Parameter(this._elementType, "$it"); switch (transformation.Kind) { case TransformationNodeKind.Aggregate: var aggregateClause = this._transformation as AggregateTransformationNode; _aggregateStatements = aggregateClause.Statements; ResultClrType = AggregationDynamicTypeProvider.GetResultType <DynamicTypeWrapper>(_model, null, _aggregateStatements); break; case TransformationNodeKind.GroupBy: var groupByClause = this._transformation as GroupByTransformationNode; _groupingProperties = groupByClause.GroupingProperties; if (groupByClause.ChildTransformation != null) { if (groupByClause.ChildTransformation.Kind == TransformationNodeKind.Aggregate) { _aggregateStatements = ((AggregateTransformationNode)groupByClause.ChildTransformation).Statements; } else { throw new NotImplementedException(); } } _groupByClrType = AggregationDynamicTypeProvider.GetResultType <DynamicTypeWrapper>(_model, _groupingProperties, null); ResultClrType = AggregationDynamicTypeProvider.GetResultType <DynamicTypeWrapper>(_model, _groupingProperties, _aggregateStatements); break; default: throw new NotSupportedException(String.Format(CultureInfo.InvariantCulture, SRResources.NotSupportedTransformationKind, transformation.Kind)); } _groupByClrType = _groupByClrType ?? typeof(DynamicTypeWrapper); }
public override ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { if (assembliesResolver == null) { throw new ArgumentNullException(nameof(assembliesResolver)); } var result = new List <Type>(); result.AddRange(base.GetControllerTypes(assembliesResolver)); var assemblies = assembliesResolver.GetAssemblies(); foreach (Assembly assembly in assemblies.Where(assembly => (assembly == null || assembly.IsDynamic) && _dynamicAssemblies.Contains(assembly))) { result.AddRange(assembly.GetTypes().Where(x => !result.Contains(x)).Where(x => IsControllerTypePredicate(x)).ToArray()); } return(result); }
/// <summary> /// Returns a list of controllers available for the application. /// </summary> /// <returns>An <see cref="ICollection{Type}" /> of controllers.</returns> public override ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { HttpControllerTypeCacheSerializer serializer = new HttpControllerTypeCacheSerializer(); // First, try reading from the cache on disk List<Type> matchingTypes = ReadTypesFromCache(TypeCacheName, IsControllerTypePredicate, serializer); if (matchingTypes != null) { return matchingTypes; } // If reading from the cache failed, enumerate over every assembly looking for a matching type matchingTypes = base.GetControllerTypes(assembliesResolver).ToList(); // Finally, save the cache back to disk SaveTypesToCache(TypeCacheName, matchingTypes, serializer); return matchingTypes; }
public ICollection<Type> GetHandlerTypes(IAssembliesResolver assembliesResolver) { if (assembliesResolver == null) { throw Error.ArgumentNull("assembliesResolver"); } List<Type> result = new List<Type>(); // Go through all assemblies referenced by the application and search for types matching a predicate ICollection<Assembly> assemblies = assembliesResolver.GetAssemblies(); foreach (Assembly assembly in assemblies) { Type[] exportedTypes; if (assembly == null || assembly.IsDynamic) { // can't call GetExportedTypes on a dynamic assembly continue; } try { exportedTypes = assembly.GetTypes(); } catch (ReflectionTypeLoadException ex) { exportedTypes = ex.Types; } catch { // We deliberately ignore all exceptions when building the cache. continue; } if (exportedTypes != null) { result.AddRange(exportedTypes.Where(type => TypeIsVisible(type) && this.isHandlerTypePredicate(type))); } } return result; }
private ConcurrentDictionary <string, HttpControllerDescriptor> InitializeControllerInfoCache() { var result = new ConcurrentDictionary <string, HttpControllerDescriptor>(StringComparer.OrdinalIgnoreCase); // Create a lookup table where key is "version.controller". The value of "version" is the last // segment of the full namespace. For example: // MyApplication.Controllers.V1.ProductsController => "V1.Products" IAssembliesResolver assembliesResolver = _configuration.Services.GetAssembliesResolver(); IHttpControllerTypeResolver controllersResolver = _configuration.Services.GetHttpControllerTypeResolver(); ICollection <Type> controllerTypes = controllersResolver.GetControllerTypes(assembliesResolver); foreach (Type controllerType in controllerTypes) { var segments = controllerType.Namespace.Split(Type.Delimiter); // For the dictionary key, strip "Controller" from the end of the type name. // This matches the behavior of DefaultHttpControllerSelector. var controllerName = controllerType.Name.Remove(controllerType.Name.Length - ControllerSuffix.Length); var key = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", segments[segments.Length - 1], controllerName); // Check for duplicate keys. if (result.Keys.Contains(key)) { _duplicateControllers.Add(key); } else { result.TryAdd(key, new HttpControllerDescriptor(_configuration, controllerName, controllerType)); } } // Remove any duplicates from the dictionary, because these create ambiguous matches. // For example, "Foo.V1.ProductsController" and "Bar.V1.ProductsController" both map to "v1.products". foreach (string duplicateController in _duplicateControllers) { HttpControllerDescriptor descriptor; result.TryRemove(duplicateController, out descriptor); } return(result); }
public ICollection <Type> GetHandlerTypes(IAssembliesResolver assembliesResolver) { if (assembliesResolver == null) { throw Error.ArgumentNull("assembliesResolver"); } List <Type> result = new List <Type>(); // Go through all assemblies referenced by the application and search for types matching a predicate ICollection <Assembly> assemblies = assembliesResolver.GetAssemblies(); foreach (Assembly assembly in assemblies) { Type[] exportedTypes; if (assembly == null || assembly.IsDynamic) { // can't call GetExportedTypes on a dynamic assembly continue; } try { exportedTypes = assembly.GetTypes(); } catch (ReflectionTypeLoadException ex) { exportedTypes = ex.Types; } catch { // We deliberately ignore all exceptions when building the cache. continue; } if (exportedTypes != null) { result.AddRange(exportedTypes.Where(type => TypeIsVisible(type) && this.isHandlerTypePredicate(type))); } } return(result); }
/// <summary> /// Returns a list of controllers available for the application. /// </summary> /// <returns>An <see cref="ICollection{Type}"/> of controllers.</returns> public virtual ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { // Go through all assemblies referenced by the application and search for types matching a predicate IEnumerable<Type> typesSoFar = Type.EmptyTypes; ICollection<Assembly> assemblies = assembliesResolver.GetAssemblies(); foreach (Assembly assembly in assemblies) { if (assembly.IsDynamic) { // can't call GetExportedTypes on a dynamic assembly continue; } typesSoFar = typesSoFar.Concat(assembly.GetExportedTypes()); } return typesSoFar.Where(x => IsControllerTypePredicate(x)).ToList(); }
protected static TestServer CreateTestServer(IAssembliesResolver assembliesResolver, Action <Type, IFilter> filterProvider, Func <Type, object> dependencyResolver, string baseUrl = "http://localhost") { var testServer = TestServer.Create(app => { var config = new HttpConfiguration(); config.Services.Replace(typeof(IAssembliesResolver), assembliesResolver); WebApiConfig.Register(config); config.Services.Add((typeof(IFilterProvider)), new DelegateFilterProvider(filterProvider)); config.DependencyResolver = new DelegateDependencyResolver(dependencyResolver); app.UseWebApi(config); }); testServer.BaseAddress = new Uri(baseUrl); return(testServer); }
/// <summary> /// Initializes a new instance of the routing configuration class. /// </summary> /// <returns>A new instance of the routing configuration class.</returns> internal static IWebApiAssembliesResolver Create(MockAssembly assembly = null) { IAssembliesResolver resolver = null; if (assembly != null) { resolver = new TestAssemblyResolver(assembly); } else { Mock <IAssembliesResolver> mockAssembliesResolver = new Mock <IAssembliesResolver>(); mockAssembliesResolver .Setup(r => r.GetAssemblies()) .Returns(new Assembly[0]); resolver = mockAssembliesResolver.Object; } return(new WebApiAssembliesResolver(resolver)); }
private ConcurrentDictionary <string, HttpControllerDescriptor> InitTypeCache() { IAssembliesResolver assembliesResolver = _configuration.Services.GetAssembliesResolver(); IHttpControllerTypeResolver controllersResolver = _configuration.Services.GetHttpControllerTypeResolver(); ICollection <Type> controllerTypes = controllersResolver.GetControllerTypes(assembliesResolver); var dict = new ConcurrentDictionary <string, HttpControllerDescriptor>(); foreach (Type type in controllerTypes) { if (type.FullName != null) { string controllerName = type.Name.Substring(0, type.Name.Length - ControllerSuffix.Length); dict.TryAdd(type.FullName.ToLowerInvariant(), new HttpControllerDescriptor(_configuration, controllerName, type)); } } return(dict); }
private Dictionary <ControllerIdentification, ILookup <string, Type> > InitializeCache() { IAssembliesResolver assembliesResolver = this._configuration.Services.GetAssembliesResolver(); IHttpControllerTypeResolver controllersResolver = this._configuration.Services.GetHttpControllerTypeResolver(); IControllerIdentificationDetector controllerIdentificationDetector = this._configuration.DependencyResolver.GetControllerIdentificationDetector(); // group controllers by name ICollection <Type> controllerTypes = controllersResolver.GetControllerTypes(assembliesResolver); IEnumerable <IGrouping <ControllerIdentification, Type> > groupedByName = controllerTypes.Select( x => new { ClrType = x, Id = controllerIdentificationDetector.GetIdentification(x) }) .GroupBy(x => x.Id, x => x.ClrType); return(groupedByName.ToDictionary( g => g.Key, g => g.ToLookup(t => t.Namespace ?? String.Empty, StringComparer.OrdinalIgnoreCase), ControllerIdentification.Comparer)); }
/// <summary> /// Returns a list of controllers available for the application. /// </summary> /// <returns>An <see cref="ICollection{Type}" /> of controllers.</returns> public override ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { HttpControllerTypeCacheSerializer serializer = new HttpControllerTypeCacheSerializer(); // First, try reading from the cache on disk List <Type> matchingTypes = ReadTypesFromCache(TypeCacheName, IsControllerTypePredicate, serializer); if (matchingTypes != null) { return(matchingTypes); } // If reading from the cache failed, enumerate over every assembly looking for a matching type matchingTypes = base.GetControllerTypes(assembliesResolver).ToList(); // Finally, save the cache back to disk SaveTypesToCache(TypeCacheName, matchingTypes, serializer); return(matchingTypes); }
/// <summary> /// Returns a list of controllers available for the application. /// </summary> /// <returns>An <see cref="ICollection{Type}"/> of controllers.</returns> public virtual ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { // Go through all assemblies referenced by the application and search for types matching a predicate IEnumerable <Type> typesSoFar = Type.EmptyTypes; ICollection <Assembly> assemblies = assembliesResolver.GetAssemblies(); foreach (Assembly assembly in assemblies) { if (assembly.IsDynamic) { // can't call GetExportedTypes on a dynamic assembly continue; } typesSoFar = typesSoFar.Concat(assembly.GetExportedTypes()); } return(typesSoFar.Where(x => IsControllerTypePredicate(x)).ToList()); }
internal static HashSet <string> GetMobileAppControllerNames(this HttpConfiguration config) { if (config == null) { throw new ArgumentNullException("config"); } IAssembliesResolver assemblyResolver = config.Services.GetAssembliesResolver(); IHttpControllerTypeResolver controllerTypeResolver = config.Services.GetHttpControllerTypeResolver(); Type[] controllerTypes = controllerTypeResolver.GetControllerTypes(assemblyResolver).ToArray(); // Add controllers that have the MobileAppController attribute IEnumerable <string> matches = controllerTypes .Where(t => t.GetCustomAttributes(typeof(MobileAppControllerAttribute), true).Any()) .Select(t => t.Name.Substring(0, t.Name.Length - DefaultHttpControllerSelector.ControllerSuffix.Length)); HashSet <string> result = new HashSet <string>(matches, StringComparer.OrdinalIgnoreCase); return(result); }
public ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { return(new Type[] { typeof(ActivitiesController), typeof(AlarmsController), typeof(AuthenticationController), typeof(ConfigurationController), typeof(ContainersController), typeof(DocumentationController), typeof(EventsController), typeof(FilesController), typeof(ManifestsController), typeof(ReportsController), typeof(PlanNodesController), typeof(PlansController), typeof(TerminalsController), typeof(UsersController), typeof(WarehousesController), typeof(WebServicesController) }); }
/// <summary> /// </summary> /// <param name="config"></param> /// <returns></returns> public static HashSet <string> GetTableControllerNames(this HttpConfiguration config) { if (config == null) { throw new ArgumentNullException("config"); } IAssembliesResolver assemblyResolver = config.Services.GetAssembliesResolver(); IHttpControllerTypeResolver controllerTypeResolver = config.Services.GetHttpControllerTypeResolver(); Type[] controllerTypes = controllerTypeResolver.GetControllerTypes(assemblyResolver).ToArray(); // Add controllers deriving from TableController IEnumerable <string> matches = controllerTypes .Where(t => typeof(TableController).IsAssignableFrom(t)) .Select(t => t.Name.Substring(0, t.Name.Length - DefaultHttpControllerSelector.ControllerSuffix.Length)); HashSet <string> result = new HashSet <string>(matches, StringComparer.OrdinalIgnoreCase); return(result); }
public override ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { HashSet <Type> allControllers = base.GetControllerTypes(assembliesResolver).ToHashSet(); Dictionary <string, BinaryContentUtils.DbBinaryConfig> proxyBinaryConfigs = new Dictionary <string, BinaryContentUtils.DbBinaryConfig>(); // load controllers from dependencies HashSet <IScreenControllerProxy> visited = new HashSet <IScreenControllerProxy>(); foreach (var controller in allControllers.ToArray()) { var controllerProxy = ScreenServicesApiController.TryGetControllerProxy(controller); if (controllerProxy != null) { CollectDependenciesControllerTypesAndBinaryConfigs(controllerProxy, visited, allControllers, proxyBinaryConfigs); } } ScreenServicesApiController.SetDatabaseBinaries(proxyBinaryConfigs); return(allControllers); }
/// <summary> /// Activa la configuración para diagnosticar la inicialización del WebApi. /// </summary> /// <param name="config">Objeto con la configuración del WebApi</param> private static void EnabelDiagnosticWebApi(HttpConfiguration config) { IAssembliesResolver assembliesResolver = config.Services.GetAssembliesResolver(); ICollection <Assembly> assemblies = assembliesResolver.GetAssemblies(); StringBuilder errorsBuilder = new StringBuilder(); foreach (Assembly assembly in assemblies) { Type[] exportedTypes = null; if (assembly == null || assembly.IsDynamic) { // can't call GetExportedTypes on a dynamic assembly continue; } try { exportedTypes = assembly.GetExportedTypes(); } catch (ReflectionTypeLoadException ex) { exportedTypes = ex.Types; } catch (Exception ex) { errorsBuilder.AppendLine(ex.ToString()); } } if (errorsBuilder.Length > 0) { //Log errors into Event Log Trace.TraceError(errorsBuilder.ToString()); } config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; //config.EnableSystemDiagnosticsTracing(); //var ev = new System.Diagnostics.EventLogTraceListener(); }
// This code is copied from DefaultHttpControllerTypeResolver.GetControllerTypes. internal static IEnumerable <Type> GetLoadedTypes(IAssembliesResolver assembliesResolver) { Contract.Requires(assembliesResolver != null); var result = new List <Type>(); // Go through all assemblies referenced by the application and search for types matching a predicate var assemblies = assembliesResolver.GetAssemblies(); Contract.Assume(assemblies != null); foreach (var assembly in assemblies) { Type[] exportedTypes; if (assembly == null || assembly.IsDynamic) { // can't call GetTypes on a null (or dynamic?) assembly continue; } try { exportedTypes = assembly.GetTypes(); } catch (ReflectionTypeLoadException ex) { exportedTypes = ex.Types; } catch { continue; } if (exportedTypes != null) { result.AddRange(exportedTypes.Where(t => t != null && t.IsVisible)); } } return(result); }
public IQueryable ApplyTo(IQueryable query, IAssembliesResolver assembliesResolver) { if (query == null) { throw new ArgumentNullException("query"); } if (assembliesResolver == null) { throw new ArgumentNullException("assembliesResolver"); } var typeQuery = query as IQueryable <T>; if (typeQuery == null) { return(query); } var facetFields = RawValue.Split(','); return(facetFields.Aggregate(typeQuery, (current, facetField) => current.FacetOn(GenerateMemberExpression <string>(facetField), 1))); }
internal static IEnumerable<Type> GetLoadedTypes(IAssembliesResolver assembliesResolver) { List<Type> result = new List<Type>(); // Go through all assemblies referenced by the application and search for types matching a predicate ICollection<Assembly> assemblies = assembliesResolver.GetAssemblies(); foreach (Assembly assembly in assemblies) { Type[] exportedTypes = null; if (assembly == null || assembly.IsDynamic) { // can't call GetExportedTypes on a dynamic assembly continue; } try { exportedTypes = assembly.GetExportedTypes(); } catch (ReflectionTypeLoadException ex) { exportedTypes = ex.Types; } catch { continue; } if (exportedTypes != null) { result.AddRange(exportedTypes.Where(t => t != null)); } } return result; }
public static Type GetClrType(IEdmTypeReference edmTypeReference, IEdmModel edmModel, IAssembliesResolver assembliesResolver) { Contract.Requires(edmTypeReference != null); Contract.Requires(edmModel != null); Contract.Requires(assembliesResolver != null); var primitiveClrType = BuiltInTypesMapping.Where(kvp => edmTypeReference.GetDefinition().IsEquivalentTo(kvp.Value) && (!edmTypeReference.IsNullable || IsNullable(kvp.Key))).Select(kvp => kvp.Key).FirstOrDefault(); if (primitiveClrType != null) { return primitiveClrType; } var edmType = edmTypeReference.GetDefinition(); Contract.Assume(edmType is IEdmSchemaType); var clrType = GetClrType(edmType, edmModel, assembliesResolver); if (clrType != null && clrType.IsEnum && edmTypeReference.IsNullable) { return clrType.ToNullable(); } return clrType; }
private static IEnumerable<Type> GetMatchingTypes(string edmFullName, IAssembliesResolver assembliesResolver) { return TypeHelper.GetLoadedTypes(assembliesResolver).Where(t => t.IsPublic && t.EdmFullName() == edmFullName); }
public static Type GetClrType(IEdmType edmType, IEdmModel edmModel, IAssembliesResolver assembliesResolver) { IEdmSchemaType edmSchemaType = edmType as IEdmSchemaType; Contract.Assert(edmSchemaType != null); ClrTypeAnnotation annotation = edmModel.GetAnnotationValue<ClrTypeAnnotation>(edmSchemaType); if (annotation != null) { return annotation.ClrType; } string typeName = edmSchemaType.FullName(); IEnumerable<Type> matchingTypes = GetMatchingTypes(typeName, assembliesResolver); if (matchingTypes.Count() > 1) { throw Error.Argument("edmTypeReference", SRResources.MultipleMatchingClrTypesForEdmType, typeName, String.Join(",", matchingTypes.Select(type => type.AssemblyQualifiedName))); } edmModel.SetAnnotationValue<ClrTypeAnnotation>(edmSchemaType, new ClrTypeAnnotation(matchingTypes.SingleOrDefault())); return matchingTypes.SingleOrDefault(); }
public static Type GetClrType(IEdmTypeReference edmTypeReference, IEdmModel edmModel, IAssembliesResolver assembliesResolver) { if (edmTypeReference == null) { throw Error.ArgumentNull("edmTypeReference"); } Type primitiveClrType = _builtInTypesMapping .Where(kvp => edmTypeReference.Definition.IsEquivalentTo(kvp.Value) && (!edmTypeReference.IsNullable || IsNullable(kvp.Key))) .Select(kvp => kvp.Key) .FirstOrDefault(); if (primitiveClrType != null) { return primitiveClrType; } else { Type clrType = GetClrType(edmTypeReference.Definition, edmModel, assembliesResolver); if (clrType != null && clrType.IsEnum && edmTypeReference.IsNullable) { return clrType.ToNullable(); } return clrType; } }
public override ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { var controllers = base.GetControllerTypes(assembliesResolver); controllers = this.resolver(controllers); return controllers; }
/// <summary> /// Apply the apply query to the given IQueryable. /// </summary> /// <remarks> /// The <see cref="ODataQuerySettings.HandleNullPropagation"/> property specifies /// how this method should handle null propagation. /// </remarks> /// <param name="query">The original <see cref="IQueryable"/>.</param> /// <param name="querySettings">The <see cref="ODataQuerySettings"/> that contains all the query application related settings.</param> /// <param name="assembliesResolver">The <see cref="IAssembliesResolver"/> to use.</param> /// <returns>The new <see cref="IQueryable"/> after the filter query has been applied to.</returns> public IQueryable ApplyTo(IQueryable query, ODataQuerySettings querySettings, IAssembliesResolver assembliesResolver) { if (query == null) { throw Error.ArgumentNull("query"); } if (querySettings == null) { throw Error.ArgumentNull("querySettings"); } if (assembliesResolver == null) { throw Error.ArgumentNull("assembliesResolver"); } if (Context.ElementClrType == null) { throw Error.NotSupported(SRResources.ApplyToOnUntypedQueryOption, "ApplyTo"); } ApplyClause applyClause = ApplyClause; Contract.Assert(applyClause != null); // Ensure we have decided how to handle null propagation ODataQuerySettings updatedSettings = querySettings; if (querySettings.HandleNullPropagation == HandleNullPropagationOption.Default) { updatedSettings = new ODataQuerySettings(updatedSettings); updatedSettings.HandleNullPropagation = HandleNullPropagationOptionHelper.GetDefaultHandleNullPropagationOption(query); } foreach (var transformation in applyClause.Transformations) { if (transformation.Kind == TransformationNodeKind.Aggregate || transformation.Kind == TransformationNodeKind.GroupBy) { var binder = new AggregationBinder(updatedSettings, assembliesResolver, ResultClrType, Context.Model, transformation as TransformationNode); query = binder.Bind(query); this.ResultClrType = binder.ResultClrType; } else if (transformation.Kind == TransformationNodeKind.Filter) { var filterTransformation = transformation as FilterTransformationNode; Expression filter = FilterBinder.Bind(filterTransformation.FilterClause, ResultClrType, Context.Model, assembliesResolver, updatedSettings); query = ExpressionHelpers.Where(query, filter, ResultClrType); } } return query; }
public static Type GetClrType(IEdmType edmType, IEdmModel edmModel, IAssembliesResolver assembliesResolver) { Contract.Requires(edmType is IEdmSchemaType); Contract.Requires(edmModel != null); Contract.Requires(assembliesResolver != null); var edmSchemaType = (IEdmSchemaType) edmType; var annotation = edmModel.GetAnnotationValue<ClrTypeAnnotation>(edmSchemaType); if (annotation != null) { return annotation.ClrType; } var typeName = edmSchemaType.FullName(); var matchingTypes = GetMatchingTypes(typeName, assembliesResolver); var matchingTypesList = matchingTypes as IList<Type> ?? matchingTypes.ToList(); if (matchingTypesList.Count > 1) { throw new Exception("Multiple Matching ClrTypes For EdmType"); } edmModel.SetAnnotationValue(edmSchemaType, new ClrTypeAnnotation(matchingTypesList.SingleOrDefault())); return matchingTypesList.SingleOrDefault(); }
public override ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver) { Contract.Invariant(_controllerTypes != null); return _controllerTypes; }
/// <summary> /// Applies the $select and $expand query options to the given entity using the given <see cref="ODataQuerySettings"/>. /// </summary> /// <param name="entity">The original entity.</param> /// <param name="settings">The <see cref="ODataQuerySettings"/> that contains all the query application related settings.</param> /// <param name="assembliesResolver">The <see cref="IAssembliesResolver"/> to use.</param> /// <returns>The new entity after the $select and $expand query has been applied to.</returns> public object ApplyTo(object entity, ODataQuerySettings settings, IAssembliesResolver assembliesResolver) { if (entity == null) { throw Error.ArgumentNull("entity"); } if (settings == null) { throw Error.ArgumentNull("settings"); } if (Context.ElementClrType == null) { throw Error.NotSupported(SRResources.ApplyToOnUntypedQueryOption, "ApplyTo"); } // Ensure we have decided how to handle null propagation ODataQuerySettings updatedSettings = settings; if (settings.HandleNullPropagation == HandleNullPropagationOption.Default) { updatedSettings = new ODataQuerySettings(updatedSettings); updatedSettings.HandleNullPropagation = HandleNullPropagationOption.True; } return SelectExpandBinder.Bind(entity, updatedSettings, assembliesResolver, this); }
public static Type GetClrType(IEdmTypeReference edmTypeReference, IEdmModel edmModel, IAssembliesResolver assembliesResolver) { if (edmTypeReference == null) { throw Error.ArgumentNull("edmTypeReference"); } Type primitiveClrType = _builtInTypesMapping .Where(kvp => edmTypeReference.Definition.IsEquivalentTo(kvp.Value) && (!edmTypeReference.IsNullable || IsNullable(kvp.Key))) .Select(kvp => kvp.Key) .FirstOrDefault(); if (primitiveClrType != null) { return primitiveClrType; } else { ClrTypeAnnotation annotation = edmModel.GetAnnotationValue<ClrTypeAnnotation>(edmTypeReference.Definition); if (annotation != null) { return annotation.ClrType; } IEnumerable<Type> matchingTypes = GetMatchingTypes(edmTypeReference.FullName(), assembliesResolver); if (matchingTypes.Count() > 1) { throw Error.Argument("edmTypeReference", SRResources.MultipleMatchingClrTypesForEdmType, edmTypeReference.FullName(), String.Join(",", matchingTypes.Select(type => type.AssemblyQualifiedName))); } edmModel.SetAnnotationValue<ClrTypeAnnotation>(edmTypeReference.Definition, new ClrTypeAnnotation(matchingTypes.SingleOrDefault())); return matchingTypes.SingleOrDefault(); } }
/// <summary> /// Initializes a new instance of the <see cref="ODataQueryOptions"/> class based on the incoming request and some metadata information from /// the <see cref="ODataQueryContext"/>. /// </summary> /// <param name="context">The <see cref="ODataQueryContext"/> which contains the <see cref="IEdmModel"/> and some type information</param> /// <param name="request">The incoming request message</param> public ODataQueryOptions(ODataQueryContext context, HttpRequestMessage request) { if (context == null) { throw Error.ArgumentNull("context"); } if (request == null) { throw Error.ArgumentNull("request"); } if (request.GetConfiguration() != null) { _assembliesResolver = request.GetConfiguration().Services.GetAssembliesResolver(); } // fallback to the default assemblies resolver if none available. _assembliesResolver = _assembliesResolver ?? new DefaultAssembliesResolver(); // remember the context Context = context; // Parse the query from request Uri RawValues = new ODataRawQueryOptions(); IEnumerable<KeyValuePair<string, string>> queryParameters = request.GetQueryNameValuePairs(); foreach (KeyValuePair<string, string> kvp in queryParameters) { switch (kvp.Key) { case "$filter": RawValues.Filter = kvp.Value; ThrowIfEmpty(kvp.Value, "$filter"); Filter = new FilterQueryOption(kvp.Value, context); break; case "$orderby": RawValues.OrderBy = kvp.Value; ThrowIfEmpty(kvp.Value, "$orderby"); OrderBy = new OrderByQueryOption(kvp.Value, context); break; case "$top": RawValues.Top = kvp.Value; ThrowIfEmpty(kvp.Value, "$top"); Top = new TopQueryOption(kvp.Value, context); break; case "$skip": RawValues.Skip = kvp.Value; ThrowIfEmpty(kvp.Value, "$skip"); Skip = new SkipQueryOption(kvp.Value, context); break; case "$select": RawValues.Select = kvp.Value; break; case "$inlinecount": RawValues.InlineCount = kvp.Value; break; case "$expand": RawValues.Expand = kvp.Value; break; case "$skiptoken": RawValues.SkipToken = kvp.Value; break; default: // we don't throw if we can't recognize the query break; } } }
/// <summary> /// Apply the filter query to the given IQueryable. /// </summary> /// <remarks> /// The <see cref="ODataQuerySettings.HandleNullPropagation"/> property specifies /// how this method should handle null propagation. /// </remarks> /// <param name="query">The original <see cref="IQueryable"/>.</param> /// <param name="querySettings">The <see cref="ODataQuerySettings"/> that contains all the query application related settings.</param> /// <param name="assembliesResolver">The <see cref="IAssembliesResolver"/> to use.</param> /// <returns>The new <see cref="IQueryable"/> after the filter query has been applied to.</returns> public IQueryable ApplyTo(IQueryable query, ODataQuerySettings querySettings, IAssembliesResolver assembliesResolver) { if (query == null) { throw Error.ArgumentNull("query"); } if (querySettings == null) { throw Error.ArgumentNull("querySettings"); } if (assembliesResolver == null) { throw Error.ArgumentNull("assembliesResolver"); } if (Context.ElementClrType == null) { throw Error.NotSupported(SRResources.ApplyToOnUntypedQueryOption, "ApplyTo"); } FilterClause filterClause = FilterClause; Contract.Assert(filterClause != null); // Ensure we have decided how to handle null propagation ODataQuerySettings updatedSettings = querySettings; if (querySettings.HandleNullPropagation == HandleNullPropagationOption.Default) { updatedSettings = new ODataQuerySettings(updatedSettings); updatedSettings.HandleNullPropagation = HandleNullPropagationOptionHelper.GetDefaultHandleNullPropagationOption(query); } Expression filter = FilterBinder.Bind(filterClause, Context.ElementClrType, Context.Model, assembliesResolver, updatedSettings); query = ExpressionHelpers.Where(query, filter, Context.ElementClrType); return query; }