private static object GenerateQueryable(Type queryableType, int size, Dictionary <Type, object> createdObjectReferences) { bool isGeneric = queryableType.IsGenericType; object list; if (isGeneric) { Type listType = typeof(List <>).MakeGenericType(queryableType.GetGenericArguments()); list = GenerateCollection(listType, size, createdObjectReferences); } else { list = GenerateArray(typeof(object[]), size, createdObjectReferences); } if (list == null) { return(null); } if (isGeneric) { Type argumentType = typeof(IEnumerable <>).MakeGenericType(queryableType.GetGenericArguments()); MethodInfo asQueryableMethod = typeof(Queryable).GetMethod("AsQueryable", new[] { argumentType }); return(asQueryableMethod.Invoke(null, new[] { list })); } return(Queryable.AsQueryable((IEnumerable)list)); }
//Func<Type, IEnumerable<object>> fnGetObjects; #region CreateQuery /// <summary> /// called during deserialization. /// </summary> /// <param name="elementType"></param> /// <returns></returns> public dynamic CreateQuery(Type elementType) { dynamic ienumerable = this.fnGetObjects(elementType); Type enumerableType = ienumerable.GetType(); if (!typeof(IEnumerable <>).MakeGenericType(elementType).IsAssignableFrom(enumerableType)) { ienumerable = Enumerable.ToArray(LinqHelper.CastToGenericEnumerable(ienumerable, elementType)); //throw new InvalidOperationException(string.Format("Return value Type is {1}. Expected: {0}", typeof(IEnumerable<>).MakeGenericType(elementType), ienumerable.GetType())); } IQueryable queryable = Queryable.AsQueryable(ienumerable); IQueryProvider provider = (IQueryProvider)queryable.Provider; Type queryType = typeof(Query <>).MakeGenericType(elementType); ConstructorInfo ctor = queryType.GetConstructors()[2];//Query(IQueryProvider provider, Expression expression) ParameterExpression[] parameters = new ParameterExpression[] { Expression.Parameter(typeof(IQueryProvider)), Expression.Parameter(typeof(Expression)) }; NewExpression newexpr = Expression.New(ctor, parameters); LambdaExpression lambda = Expression.Lambda(newexpr, parameters); var newFn = lambda.Compile(); dynamic query = newFn.DynamicInvoke(new object[] { provider, Expression.Constant(queryable) }); return(query); }
public IQueryable <TResult> CreateScalarQuery <TResult>(Expression <Func <TResult> > expression) { return(QueryProvider.CreateQuery <TResult>( Expression.Call( method: GetMethodInfo(() => Queryable.Select <int, TResult>(null, (Expression <Func <int, TResult> >)null)), arg0: Expression.Call( method: GetMethodInfo(() => Queryable.AsQueryable <int>(null)), arg0: Expression.NewArrayInit(typeof(int), Expression.Constant(1))), arg1: Expression.Lambda(body: expression.Body, parameters: new[] { Expression.Parameter(typeof(int)) })))); }
public object ReadObject(XmlDictionaryReader reader, XmlObjectSerializer serializer) { object val = _serializer.ReadObject(reader, false /* verifyObjectName */); if (_isQueryable && val != null) { return(Queryable.AsQueryable((IEnumerable)val)); } return(val); }
public static IQueryable <TResult> CreateScalarQuery <TDbContext, TResult> (this TDbContext context, Expression <Func <TDbContext, TResult> > expression) where TDbContext : DbContext { var resExp = RefactorExpression <TDbContext, TResult> (expression, (TDbContext)context); var realExp = Expression.Call( method: GetMethodInfo(() => Queryable.Select <int, TResult> (null, (Expression <Func <int, TResult> >)null)), arg0: Expression.Call( method: GetMethodInfo(() => Queryable.AsQueryable <int> (null)), arg0: Expression.NewArrayInit(typeof(int), Expression.Constant(1))), arg1: Expression.Lambda(body: resExp.Body, parameters: new [] { Expression.Parameter(typeof(int)) })); return(CreateRootDbQueryProvider(context).CreateQuery <TResult> (realExp)); }
private object DeserializeHeaderContents(XmlDictionaryReader reader, MessageDescription messageDescription, MessageHeaderDescription headerDescription) { bool isQueryable; Type dataContractType = DataContractSerializerOperationFormatter.GetSubstituteDataContractType(headerDescription.Type, out isQueryable); XmlObjectSerializer serializerLocal = _serializerFactory.CreateSerializer(dataContractType, headerDescription.Name, headerDescription.Namespace, _knownTypes); object val = serializerLocal.ReadObject(reader); if (isQueryable && val != null) { return(Queryable.AsQueryable((IEnumerable)val)); } return(val); }
public IList <T> Search(string q) { var searchStatements = _searchQueryParser.ParseQuery(q); var query = Queryable.AsQueryable <T>(_context.GetSetOfType <T>()); foreach (var searchStatement in searchStatements) { var queryModifier = _queryModifierFactory.GetModifier(searchStatement.Condition); query = queryModifier.ApplyStatementToQuery(searchStatement, query); } return(query.ToList()); }
public static IQueryable <TResult> SelectScalar <TElement, TResult> (this IEnumerable <TElement> q, Expression <Func <IQueryable <TElement>, TResult> > expression) { IQueryProvider queryProvider = (q as IQueryable).Provider; var expr = RefactorExpression(expression, (IQueryable <TElement>)q); var realExp = Expression.Call( method: GetMethodInfo(() => Queryable.Select <int, TResult> (null, (Expression <Func <int, TResult> >)null)), arg0: Expression.Call( method: GetMethodInfo(() => Queryable.AsQueryable <int> (null)), arg0: Expression.NewArrayInit(typeof(int), Expression.Constant(1))), arg1: Expression.Lambda(body: expr.Body, parameters: new [] { Expression.Parameter(typeof(int)) })); return(queryProvider.CreateQuery <TResult> (realExp)); }
public virtual T Find(params object[] keyValues) { if (keyValues.Length != _keyProperties.Count) { throw new ArgumentException("Incorrect number of keys passed to find method"); } IQueryable <T> keyQuery = Queryable.AsQueryable <T>(this); for (int i = 0; i < keyValues.Length; i++) { var x = i; // nested linq keyQuery = keyQuery.Where(entity => _keyProperties[x].GetValue(entity, null).Equals(keyValues[x])); } return(keyQuery.SingleOrDefault()); }
public NHibernateNodeTypeProvider() { var methodInfoRegistry = new MethodInfoBasedNodeTypeRegistry(); methodInfoRegistry.Register( new[] { ReflectionHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.Fetch <object, object>(null, null)) }, typeof(FetchOneExpressionNode)); methodInfoRegistry.Register( new[] { ReflectionHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.FetchMany <object, object>(null, null)) }, typeof(FetchManyExpressionNode)); methodInfoRegistry.Register( new[] { ReflectionHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetch <object, object, object>(null, null)) }, typeof(ThenFetchOneExpressionNode)); methodInfoRegistry.Register( new[] { ReflectionHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetchMany <object, object, object>(null, null)) }, typeof(ThenFetchManyExpressionNode)); methodInfoRegistry.Register( new[] { ReflectionHelper.GetMethodDefinition(() => LinqExtensionMethods.Cacheable <object>(null)), ReflectionHelper.GetMethodDefinition(() => LinqExtensionMethods.CacheMode <object>(null, CacheMode.Normal)), ReflectionHelper.GetMethodDefinition(() => LinqExtensionMethods.CacheRegion <object>(null, null)), }, typeof(CacheableExpressionNode)); methodInfoRegistry.Register( new[] { ReflectionHelper.GetMethodDefinition(() => Queryable.AsQueryable(null)), ReflectionHelper.GetMethodDefinition(() => Queryable.AsQueryable <object>(null)), }, typeof(AsQueryableExpressionNode) ); methodInfoRegistry.Register( new[] { ReflectionHelper.GetMethodDefinition(() => LinqExtensionMethods.Timeout <object>(null, 0)), }, typeof(TimeoutExpressionNode) ); var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider(); nodeTypeProvider.InnerProviders.Add(methodInfoRegistry); defaultNodeTypeProvider = nodeTypeProvider; }
public static IQueryable <TElement> AsQueryable <TElement>(this Set <TElement> source) => Queryable.AsQueryable(source.AsEnumerable().AsQueryable());
private static IQueryable <TObject> BuildQueryable <TObject>(ISpecimenContext context) { return(Queryable.AsQueryable <TObject>(context.CreateMany <TObject>())); }
public static IEnumerable <MethodInfo> GetSupportedMethods() { yield return(MethodHelper.GetMethodDefinition(() => Queryable.AsQueryable(null))); yield return(MethodHelper.GetMethodDefinition(() => Queryable.AsQueryable <object>(null))); }