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)));
}
