/// <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> /// <param name="assembliesResolver"></param> public ODataQueryOptions(ODataQueryContext context, HttpRequest request, AssembliesResolver assembliesResolver) { if (context == null) { throw Error.ArgumentNull("context"); } if (request == null) { throw Error.ArgumentNull("request"); } _assembliesResolver = assembliesResolver; Context = context; Request = request; RawValues = new ODataRawQueryOptions(); var queryOptionDict = request.Query.ToDictionary(p => p.Key, p => p.Value.FirstOrDefault()); _queryOptionParser = new ODataQueryOptionParser( context.Model, context.ElementType, context.NavigationSource, queryOptionDict); BuildQueryOptions(queryOptionDict); }
///// <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> ///// <returns>The new entity after the $select and $expand query has been applied to.</returns> //public object ApplyTo(object entity, ODataQuerySettings settings, string AssembliesResolver) //{ // return ApplyTo(entity, settings, AssembliesResolver); //} /// <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 name of the assembly 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, AssembliesResolver 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, string assembliesResolver) //{ // return GetClrType(edmTypeReference, edmModel, assembliesResolver); //} public static Type GetClrType(IEdmTypeReference edmTypeReference, IEdmModel edmModel, AssembliesResolver 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 { return(GetClrType(edmTypeReference.Definition, edmModel, assembliesResolver)); } }
internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource, ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext, AssembliesResolver assembliesResolver) { IEdmProperty edmProperty = resourceType.FindProperty(property.Name); bool isDynamicProperty = false; string propertyName = property.Name; if (edmProperty != null) { propertyName = EdmLibHelpers.GetClrPropertyName(edmProperty, readContext.Model); } else { IEdmStructuredType structuredType = resourceType.StructuredDefinition(); isDynamicProperty = structuredType != null && structuredType.IsOpen; } // dynamic properties have null values IEdmTypeReference propertyType = edmProperty != null ? edmProperty.Type : null; EdmTypeKind propertyKind; object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext, out propertyKind); if (isDynamicProperty) { SetDynamicProperty(resource, resourceType, propertyKind, propertyName, value, propertyType, readContext, assembliesResolver); } else { SetDeclaredProperty(resource, propertyKind, propertyName, value, edmProperty, readContext, assembliesResolver); } }
public static void AddToCollection(this IEnumerable items, IEnumerable collection, Type elementType, Type resourceType, string propertyName, Type propertyType, AssembliesResolver assembliesResolver) { Contract.Assert(items != null); Contract.Assert(collection != null); Contract.Assert(elementType != null); Contract.Assert(resourceType != null); Contract.Assert(propertyName != null); Contract.Assert(propertyType != null); MethodInfo addMethod = null; IList list = collection as IList; if (list == null) { addMethod = collection.GetType().GetMethod("Add", new Type[] { elementType }); if (addMethod == null) { string message = Error.Format(SRResources.CollectionShouldHaveAddMethod, propertyType.FullName, propertyName, resourceType.FullName); throw new SerializationException(message); } } else if (list.GetType().IsArray) { string message = Error.Format(SRResources.GetOnlyCollectionCannotBeArray, propertyName, resourceType.FullName); throw new SerializationException(message); } items.AddToCollectionCore(collection, elementType, list, addMethod, assembliesResolver); }
/// <summary> /// Registers the Web API <see cref="IHttpController"/> types that available for the application. This /// method uses the configured <see cref="IHttpControllerTypeResolver"/> to determine which controller /// types to register. /// </summary> /// <param name="container">The container the controllers should be registered in.</param> /// <param name="configuration">The <see cref="HttpConfiguration"/> to use to get the Controller /// types to register.</param> /// <param name="assemblies">The assemblies to search.</param> /// <exception cref="ArgumentNullException">Thrown when one of the arguments is a null /// reference (Nothing in VB).</exception> public static void RegisterWebApiControllers(this Container container, HttpConfiguration configuration, IEnumerable <Assembly> assemblies) { Requires.IsNotNull(container, nameof(container)); Requires.IsNotNull(configuration, nameof(configuration)); Requires.IsNotNull(assemblies, nameof(assemblies)); IAssembliesResolver assembliesResolver = new AssembliesResolver(assemblies); var controllerTypes = GetControllerTypesFromConfiguration(configuration, assembliesResolver); foreach (Type controllerType in controllerTypes) { Registration registration = Lifestyle.Transient.CreateRegistration(controllerType, container); if (typeof(ApiController).IsAssignableFrom(controllerType)) { // Suppress the Disposable Transient Component warning, because Web API's controller factory // ensures correct disposal of controllers. registration.SuppressDiagnosticWarning(DiagnosticType.DisposableTransientComponent, justification: "Web API registers controllers for disposal when the request ends during the " + "call to ApiController.ExecuteAsync."); } container.AddRegistration(controllerType, registration); } }
private static void AddToCollectionCore(this IEnumerable items, IEnumerable collection, Type elementType, IList list, MethodInfo addMethod, AssembliesResolver assembliesResolver) { bool isNonstandardEdmPrimitiveCollection; EdmLibHelpers.IsNonstandardEdmPrimitive(elementType, assembliesResolver, out isNonstandardEdmPrimitiveCollection); foreach (object item in items) { object element = item; if (isNonstandardEdmPrimitiveCollection && element != null) { // convert non-standard edm primitives if required. element = EdmPrimitiveHelpers.ConvertPrimitiveValue(element, elementType); } if (list != null) { list.Add(element); } else { Contract.Assert(addMethod != null); addMethod.Invoke(collection, new object[] { element }); } } }
/// <summary> /// Initializes a new instance of the <see cref="ODataConventionModelBuilder"/> class. /// </summary> /// <param name="assembliesResolver">The assemblies resolve to use for type resolution</param> /// <param name="isQueryCompositionMode">If the model is being built for only querying.</param> /// <remarks>The model built if <paramref name="isQueryCompositionMode"/> is <c>true</c> has more relaxed /// inference rules and also treats all types as entity types. This constructor is intended for use by unit testing only.</remarks> public ODataConventionModelBuilder(AssembliesResolver assembliesResolver, bool isQueryCompositionMode) { if (assembliesResolver == null) { throw Error.ArgumentNull("AssembliesResolver"); } Initialize(assembliesResolver, isQueryCompositionMode); }
private Assembly[] GetAssemblies() { OnConfigureAssemblyResolution(); var rootPath = PlatformProvider.Current.GetAbsolutePath(ModulesPath); var assembliesResolver = new AssembliesResolver( new ServerAssemblySourceProvider(rootPath)); return(((IAssembliesReadOnlyResolver)assembliesResolver).GetAssemblies().ToArray()); }
public static object Bind(object entity, ODataQuerySettings settings, AssembliesResolver assembliesResolver, SelectExpandQueryOption selectExpandQuery) { Contract.Assert(entity != null); SelectExpandBinder binder = new SelectExpandBinder(settings, assembliesResolver, selectExpandQuery); return(binder.Bind(entity)); }
public static IQueryable Bind(IQueryable queryable, ODataQuerySettings settings, AssembliesResolver assembliesResolver, SelectExpandQueryOption selectExpandQuery) { Contract.Assert(queryable != null); SelectExpandBinder binder = new SelectExpandBinder(settings, assembliesResolver, selectExpandQuery); var bound = binder.Bind(queryable); return(bound); }
internal void Initialize(AssembliesResolver assembliesResolver, bool isQueryCompositionMode) { _isQueryCompositionMode = isQueryCompositionMode; _configuredNavigationSources = new HashSet <INavigationSourceConfiguration>(); _mappedTypes = new HashSet <StructuralTypeConfiguration>(); _ignoredTypes = new HashSet <Type>(); ModelAliasingEnabled = true; _allTypesWithDerivedTypeMapping = new Lazy <IDictionary <Type, List <Type> > >( () => BuildDerivedTypesMapping(assembliesResolver), isThreadSafe: false); }
public static Type GetClrType(IEdmType edmType, IEdmModel edmModel, AssembliesResolver assembliesResolver) { IEdmSchemaType edmSchemaType = edmType as IEdmSchemaType; Contract.Assert(edmSchemaType != null); string typeName = edmSchemaType.FullName(); IEnumerable <Type> matchingTypes = GetMatchingTypes(typeName, assembliesResolver); return(matchingTypes.FirstOrDefault()); }
public static void AddAssembly(this HttpConfiguration httpConfiguration, Assembly assembly) { Dispatcher.IAssembliesResolver existingAssembliesResolver = GetAssembliesResolver(httpConfiguration); ICollection <Assembly> existingAssemblies = existingAssembliesResolver.GetAssemblies(); if (!existingAssemblies.Contains(assembly)) { AssembliesResolver assembliesResolver = new AssembliesResolver(existingAssemblies); assembliesResolver.Add(assembly); httpConfiguration.Services.Replace(typeof(Dispatcher.IAssembliesResolver), assembliesResolver); } }
internal void TryAppendAssembly(byte[] rawAssembly) { Assembly asm; try { asm = Assembly.Load(rawAssembly); AssembliesResolver.Register(asm); _assemblies.Add(asm); } catch { } }
/// <summary> /// Registers the Web API <see cref="IHttpController"/> types that available for the application. This /// method uses the configured <see cref="IHttpControllerTypeResolver"/> to determine which controller /// types to register. /// </summary> /// <param name="container">The container the controllers should be registered in.</param> /// <param name="configuration">The <see cref="HttpConfiguration"/> to use to get the Controller /// types to register.</param> /// <param name="assemblies">The assemblies to search.</param> /// <exception cref="ArgumentNullException">Thrown when one of the arguments is a null /// reference (Nothing in VB).</exception> public static void RegisterWebApiControllers(this Container container, HttpConfiguration configuration, IEnumerable <Assembly> assemblies) { Requires.IsNotNull(container, "container"); Requires.IsNotNull(configuration, "configuration"); Requires.IsNotNull(assemblies, "assemblies"); IAssembliesResolver assembliesResolver = new AssembliesResolver(assemblies); var controllerTypes = GetControllerTypesFromConfiguration(configuration, assembliesResolver); controllerTypes.ForEach(type => container.Register(type, type)); }
//public static IRouteBuilder MapODataRoute<T>(this IRouteBuilder builder, string prefix) where T : class //{ // builder.Routes.Add(new ODataRoute(prefix, DefaultODataModelProvider.BuildEdmModel(typeof(T)))); // return builder; //} public static IServiceCollection AddOData <T>([NotNull] this IServiceCollection services, Action <ODataConventionModelBuilder> after = null) where T : class { services.AddOData(); var type = typeof(T); var assemblyNames = new AssembliesResolver(type.GetTypeInfo().Assembly); var model = DefaultODataModelProvider.BuildEdmModel(type, assemblyNames, after); services.AddSingleton(model); services.AddSingleton(assemblyNames); return(services); }
internal static void SetDynamicProperty(object resource, IEdmStructuredTypeReference resourceType, EdmTypeKind propertyKind, string propertyName, object propertyValue, IEdmTypeReference propertyType, ODataDeserializerContext readContext, AssembliesResolver assembliesResolver) { if (propertyKind == EdmTypeKind.Collection && propertyValue.GetType() != typeof(EdmComplexObjectCollection) && propertyValue.GetType() != typeof(EdmEnumObjectCollection)) { SetDynamicCollectionProperty(resource, propertyName, propertyValue, propertyType.AsCollection(), resourceType.StructuredDefinition(), readContext, assembliesResolver); } else { SetDynamicProperty(resource, propertyName, propertyValue, resourceType.StructuredDefinition(), readContext); } }
// figures out if the given clr type is nonstandard edm primitive like uint, ushort, char[] etc. // and returns the corresponding clr type to which we map like uint => long. public static Type IsNonstandardEdmPrimitive(Type type, out bool isNonstandardEdmPrimitive, AssembliesResolver assembliesResolver) { IEdmPrimitiveTypeReference edmType = GetEdmPrimitiveTypeReferenceOrNull(type); if (edmType == null) { isNonstandardEdmPrimitive = false; return(type); } Type reverseLookupClrType = GetClrType(edmType, EdmCoreModel.Instance, assembliesResolver); isNonstandardEdmPrimitive = (type != reverseLookupClrType); return(reverseLookupClrType); }
public SelectExpandBinder(ODataQuerySettings settings, AssembliesResolver 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; }
private static Dictionary <Type, List <Type> > BuildDerivedTypesMapping(AssembliesResolver assembliesResolver) { IEnumerable <Type> allTypes = //DefaultAssemblyPartDiscoveryProvider. TypeHelper.GetLoadedTypes(assembliesResolver).Where(t => t.GetTypeInfo().IsVisible&& t.GetTypeInfo().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.GetTypeInfo().BaseType != null && allTypeMapping.TryGetValue(type.GetTypeInfo().BaseType, out derivedTypes)) { derivedTypes.Add(type); } } return(allTypeMapping); }
internal static void SetDeclaredProperty(object resource, EdmTypeKind propertyKind, string propertyName, object propertyValue, IEdmProperty edmProperty, ODataDeserializerContext readContext, AssembliesResolver assembliesResolver) { if (propertyKind == EdmTypeKind.Collection) { SetCollectionProperty(resource, edmProperty, propertyValue, propertyName, assembliesResolver); } else { if (!readContext.IsUntyped) { if (propertyKind == EdmTypeKind.Primitive) { propertyValue = EdmPrimitiveHelpers.ConvertPrimitiveValue(propertyValue, GetPropertyType(resource, propertyName)); } } SetProperty(resource, propertyName, propertyValue); } }
// TODO: Move this into AssembliesResolver and cache results internal static IEnumerable<Type> GetLoadedTypes(AssembliesResolver assembliesResolver) { var result = new List<Type>(); foreach (var assembly in assembliesResolver.Assemblies) { // Go through all assemblies referenced by the application and search for types matching a predicate var assemblyParts = DefaultAssemblyPartDiscoveryProvider.DiscoverAssemblyParts(assembly.FullName) .Select(s => (s as AssemblyPart).Assembly); foreach (var assemblyPart in assemblyParts) { Type[] exportedTypes = null; if (assemblyPart == null || assemblyPart.IsDynamic) { // can't call GetTypes on a null (or dynamic?) assembly continue; } try { exportedTypes = assemblyPart.GetTypes(); } catch (ReflectionTypeLoadException ex) { exportedTypes = ex.Types; } catch { continue; } if (exportedTypes != null) { result.AddRange(exportedTypes.Where(t => t != null && t.GetTypeInfo().IsVisible)); } } } return result; }
// TODO: Move this into AssembliesResolver and cache results internal static IEnumerable <Type> GetLoadedTypes(AssembliesResolver assembliesResolver) { var result = new List <Type>(); foreach (var assembly in assembliesResolver.Assemblies) { // Go through all assemblies referenced by the application and search for types matching a predicate var assemblyParts = DefaultAssemblyPartDiscoveryProvider.DiscoverAssemblyParts(assembly.FullName) .Select(s => (s as AssemblyPart).Assembly); foreach (var assemblyPart in assemblyParts) { Type[] exportedTypes = null; if (assemblyPart == null || assemblyPart.IsDynamic) { // can't call GetTypes on a null (or dynamic?) assembly continue; } try { exportedTypes = assemblyPart.GetTypes(); } catch (ReflectionTypeLoadException ex) { exportedTypes = ex.Types; } catch { continue; } if (exportedTypes != null) { result.AddRange(exportedTypes.Where(t => t != null && t.GetTypeInfo().IsVisible)); } } } return(result); }
/// <summary> /// Registers the Web API <see cref="IHttpController"/> types that available for the application. This /// method uses the configured <see cref="IHttpControllerTypeResolver"/> to determine which controller /// types to register. /// </summary> /// <param name="container">The container the controllers should be registered in.</param> /// <param name="configuration">The <see cref="HttpConfiguration"/> to use to get the Controller /// types to register.</param> /// <param name="assemblies">The assemblies to search.</param> /// <exception cref="ArgumentNullException">Thrown when one of the arguments is a null /// reference (Nothing in VB).</exception> public static void RegisterWebApiControllers(this Container container, HttpConfiguration configuration, IEnumerable <Assembly> assemblies) { Requires.IsNotNull(container, "container"); Requires.IsNotNull(configuration, "configuration"); Requires.IsNotNull(assemblies, "assemblies"); IAssembliesResolver assembliesResolver = new AssembliesResolver(assemblies); var controllerTypes = GetControllerTypesFromConfiguration(configuration, assembliesResolver); foreach (Type controllerType in controllerTypes) { Registration registration = Lifestyle.Transient.CreateRegistration(controllerType, container); // Suppress the Disposable Transient Component warning, because MVC's controller factory // ensures correct disposal of controllers. registration.SuppressDiagnosticWarning(DiagnosticType.DisposableTransientComponent); container.AddRegistration(controllerType, registration); } }
public static void AddToCollection(this IEnumerable items, IEnumerable collection, Type elementType, string paramName, Type paramType, AssembliesResolver assembliesResolver) { Contract.Assert(items != null); Contract.Assert(collection != null); Contract.Assert(elementType != null); Contract.Assert(paramType != null); MethodInfo addMethod = null; IList list = collection as IList; if (list == null) { addMethod = collection.GetType().GetMethod("Add", new Type[] { elementType }); if (addMethod == null) { string message = Error.Format(SRResources.CollectionParameterShouldHaveAddMethod, paramType, paramName); throw new SerializationException(message); } } items.AddToCollectionCore(collection, elementType, list, addMethod, assembliesResolver); }
public static void RegisterWebApiControllers(this IContainer container, HttpConfiguration configuration) { var assembliesResolver = configuration.Services.GetAssembliesResolver(); if (assembliesResolver == null) { throw new InvalidOperationException("Could not find AssembliesResolver"); } var typeResolver = configuration.Services.GetHttpControllerTypeResolver(); var apiControllerType = typeof(ApiController); var assemblies = assembliesResolver.GetAssemblies(); var cachedAssembliesResolver = new AssembliesResolver(assemblies.ToList()); var apiControllerTypes = typeResolver.GetControllerTypes(cachedAssembliesResolver).Select(t => t); foreach (var type in apiControllerTypes) { container.Register(type, type); } }
///// <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> ///// <returns>The new entity after the $select and $expand query has been applied to.</returns> //public object ApplyTo(object entity, ODataQuerySettings settings, string AssembliesResolver) //{ // return ApplyTo(entity, settings, AssembliesResolver); //} /// <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 name of the assembly 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, AssembliesResolver 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); }
internal static void SetDynamicCollectionProperty(object resource, string propertyName, object value, IEdmCollectionTypeReference edmPropertyType, IEdmStructuredType structuredType, ODataDeserializerContext readContext, AssembliesResolver assembliesResolver) { Contract.Assert(value != null); Contract.Assert(readContext != null); Contract.Assert(readContext.Model != null); IEnumerable collection = value as IEnumerable; Contract.Assert(collection != null); Type resourceType = resource.GetType(); Type elementType = EdmLibHelpers.GetClrType(edmPropertyType.ElementType(), readContext.Model, assembliesResolver); Type propertyType = typeof(ICollection<>).MakeGenericType(elementType); IEnumerable newCollection; if (CollectionDeserializationHelpers.TryCreateInstance(propertyType, edmPropertyType, elementType, out newCollection)) { collection.AddToCollection(newCollection, elementType, resourceType, propertyName, propertyType, assembliesResolver); SetDynamicProperty(resource, propertyName, newCollection, structuredType, readContext); } }
internal static void SetCollectionProperty(object resource, string propertyName, IEdmCollectionTypeReference edmPropertyType, object value, bool clearCollection, AssembliesResolver assembliesResolver) { if (value != null) { IEnumerable collection = value as IEnumerable; Contract.Assert(collection != null, "SetCollectionProperty is always passed the result of ODataFeedDeserializer or ODataCollectionDeserializer"); Type resourceType = resource.GetType(); Type propertyType = GetPropertyType(resource, propertyName); Type elementType; if (!propertyType.IsCollection(out elementType)) { string message = Error.Format(SRResources.PropertyIsNotCollection, propertyType.FullName, propertyName, resourceType.FullName); throw new SerializationException(message); } IEnumerable newCollection; if (CanSetProperty(resource, propertyName) && CollectionDeserializationHelpers.TryCreateInstance(propertyType, edmPropertyType, elementType, out newCollection)) { // settable collections collection.AddToCollection(newCollection, elementType, resourceType, propertyName, propertyType, assembliesResolver); if (propertyType.IsArray) { newCollection = CollectionDeserializationHelpers.ToArray(newCollection, elementType); } SetProperty(resource, propertyName, newCollection); } else { // get-only collections. newCollection = GetProperty(resource, propertyName) as IEnumerable; if (newCollection == null) { string message = Error.Format(SRResources.CannotAddToNullCollection, propertyName, resourceType.FullName); throw new SerializationException(message); } if (clearCollection) { newCollection.Clear(propertyName, resourceType); } collection.AddToCollection(newCollection, elementType, resourceType, propertyName, propertyType, assembliesResolver); } } }
/// <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 assembly 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, AssembliesResolver assembliesResolver) { if (query == null) { throw Error.ArgumentNull("query"); } if (assembliesResolver == null) { throw Error.ArgumentNull("AssembliesResolver"); } if (Context.ElementClrType == null) { throw Error.NotSupported(SRResources.ApplyToOnUntypedQueryOption, "ApplyTo"); } var filter = FilterBinder.Bind(FilterClause, Context.ElementClrType, Context.Model, assembliesResolver, querySettings); return(ExpressionHelpers.Where(query, filter, Context.ElementClrType)); }
internal static void SetCollectionProperty(object resource, IEdmProperty edmProperty, object value, string propertyName, AssembliesResolver assembliesResolver) { Contract.Assert(edmProperty != null); SetCollectionProperty(resource, propertyName, edmProperty.Type.AsCollection(), value, false, assembliesResolver); }
// /// <summary> // /// Initializes a new instance of the <see cref="ODataConventionModelBuilder"/> class. // /// </summary> // public ODataConventionModelBuilder(string assembliesResolver) // { // Initialize( //assembliesResolver, //isQueryCompositionMode: false //); // } /// <summary> /// Initializes a new <see cref="ODataConventionModelBuilder"/>. /// </summary> public ODataConventionModelBuilder(AssembliesResolver assembliesResolver) : this(assembliesResolver, isQueryCompositionMode : false) { }
public static Type IsNonstandardEdmPrimitive(Type type, AssembliesResolver assembliesResolver, out bool isNonstandardEdmPrimitive) { return(IsNonstandardEdmPrimitive(type, out isNonstandardEdmPrimitive, assembliesResolver)); }
/// <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 assembly 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, AssembliesResolver assembliesResolver) { if (query == null) { throw Error.ArgumentNull("query"); } if (assembliesResolver == null) { throw Error.ArgumentNull("AssembliesResolver"); } if (Context.ElementClrType == null) { throw Error.NotSupported(SRResources.ApplyToOnUntypedQueryOption, "ApplyTo"); } var filter = FilterBinder.Bind(FilterClause, Context.ElementClrType, Context.Model, assembliesResolver, querySettings); return ExpressionHelpers.Where(query, filter, Context.ElementClrType); }
static void Main(string[] args) { Karyon.EurekaIntegration.ApplicationLifecycleController netflixoss = null; HttpSelfHostServer server = null; bool registered = false; System.Diagnostics.Trace.Listeners.Add(new System.Diagnostics.ConsoleTraceListener(true)); try { //register application at Eureka service. netflixoss = Karyon.EurekaIntegration.ApplicationLifecycleController.CreateInstance(); registered = netflixoss.RegisterApplicationInstance(); } catch (Exception ex) { Console.WriteLine("Exception: " + ex.ToString()); } if (!registered) { Console.WriteLine("Press Enter to quit."); Console.ReadLine(); if (netflixoss != null) { netflixoss.Dispose(); } return; } try { Console.WriteLine("Configuring instance services..."); string listenToPath = string.Format("http://{0}:{1}", (netflixoss.AppConfig.ListenToPublic ? netflixoss.DataCenterMetadata.PublicIPv4 : netflixoss.DataCenterMetadata.LocalIPv4), netflixoss.AppConfig.ApplicationPort.ToString()); HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(listenToPath); AssembliesResolver assemblyResolver = new AssembliesResolver(); config.Services.Replace(typeof(IAssembliesResolver), assemblyResolver); config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; config.Routes.MapHttpRoute("API Default", "api/{controller}"); //add Karyon.NET healthcheck API endpoint as "<root>/healthcheck" config.Routes.MapHttpRoute("Healthcheck", "healthcheck", defaults: new { controller = "Healthcheck" }); server = new HttpSelfHostServer(config); server.OpenAsync().Wait(); Console.WriteLine(""); Console.WriteLine("Listening to " + config.BaseAddress.ToString() + "; Press Enter to quit."); Console.ReadLine(); } catch (Exception ex) { Console.WriteLine("Exception: " + ex.ToString()); Console.WriteLine("Press Enter to quit."); Console.ReadLine(); } finally { if (server != null) { server.CloseAsync(); } try { if (netflixoss != null) { netflixoss.UnregisterApplicationInstance(); } } catch (Exception ex) { Console.WriteLine("Exception: " + ex.Message); } finally { if (netflixoss != null) { netflixoss.Dispose(); } } } }
// OData formatter requires the type name of the entity that is being written if the type has derived types. // Expression // source is GrandChild ? "GrandChild" : ( source is Child ? "Child" : "Root" ) // Notice that the order is important here. The most derived type must be the first to check. // If entity framework had a way to figure out the type name without selecting the whole object, we don't have to do this magic. internal static Expression CreateTypeNameExpression(Expression source, IEdmEntityType elementType, IEdmModel model, AssembliesResolver assembliesResolver) { IReadOnlyList <IEdmEntityType> derivedTypes = GetAllDerivedTypes(elementType, model); if (derivedTypes.Count == 0) { // no inheritance. return(null); } else { Expression expression = Expression.Constant(elementType.FullName()); for (int i = 0; i < derivedTypes.Count; i++) { Type clrType = EdmLibHelpers.GetClrType(derivedTypes[i], model, assembliesResolver); if (clrType == null) { throw new ODataException(Error.Format(SRResources.MappingDoesNotContainEntityType, derivedTypes[0].FullName())); } expression = Expression.Condition( test: Expression.TypeIs(source, clrType), ifTrue: Expression.Constant(derivedTypes[i].FullName()), ifFalse: expression); } return(expression); } }
private static IEnumerable<Type> GetMatchingTypes(string edmFullName, AssembliesResolver assembliesResolver) { return TypeHelper.GetLoadedTypes(assembliesResolver) .Where(t => t.GetTypeInfo().IsPublic && t.EdmFullName() == edmFullName); }
private static IEnumerable <Type> GetMatchingTypes(string edmFullName, AssembliesResolver assembliesResolver) { return (TypeHelper.GetLoadedTypes(assembliesResolver) .Where(t => t.GetTypeInfo().IsPublic&& t.EdmFullName() == edmFullName)); }
// figures out if the given clr type is nonstandard edm primitive like uint, ushort, char[] etc. // and returns the corresponding clr type to which we map like uint => long. public static Type IsNonstandardEdmPrimitive(Type type, out bool isNonstandardEdmPrimitive, AssembliesResolver assembliesResolver) { IEdmPrimitiveTypeReference edmType = GetEdmPrimitiveTypeReferenceOrNull(type); if (edmType == null) { isNonstandardEdmPrimitive = false; return type; } Type reverseLookupClrType = GetClrType(edmType, EdmCoreModel.Instance, assembliesResolver); isNonstandardEdmPrimitive = (type != reverseLookupClrType); return reverseLookupClrType; }
public static Type IsNonstandardEdmPrimitive(Type type, AssembliesResolver assembliesResolver, out bool isNonstandardEdmPrimitive) { return IsNonstandardEdmPrimitive(type, out isNonstandardEdmPrimitive, assembliesResolver); }
public static Type GetClrType(IEdmType edmType, IEdmModel edmModel, AssembliesResolver assembliesResolver) { IEdmSchemaType edmSchemaType = edmType as IEdmSchemaType; Contract.Assert(edmSchemaType != null); string typeName = edmSchemaType.FullName(); IEnumerable<Type> matchingTypes = GetMatchingTypes(typeName, assembliesResolver); return matchingTypes.FirstOrDefault(); }
//public static Type GetClrType(IEdmTypeReference edmTypeReference, IEdmModel edmModel, string assembliesResolver) //{ // return GetClrType(edmTypeReference, edmModel, assembliesResolver); //} public static Type GetClrType(IEdmTypeReference edmTypeReference, IEdmModel edmModel, AssembliesResolver 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 { return GetClrType(edmTypeReference.Definition, edmModel, assembliesResolver); } }