public IEnumerable <T> CreateSplittedEnumerable <TInner>(MethodCallExpression call, Expression innerExpression)
{
IEnumerable <TInner> enumerable = Query.Provider.CreateQuery <TInner>(innerExpression);
// We need to ask for the GetEnumerator to be able to check the query
// This call will throw if the LINQ-to-SQL can't produce the query
IEnumerator <TInner> enumerator = enumerable.GetEnumerator();
// Success!
// We transform back the enumerator to an enumerable
IEnumerable <TInner> enumerable2 = new FakeEnumerable <TInner>(enumerator, enumerable);
// "Quick-n-dirty". We use a fake Queryable. The "right" way would probably be
// transform all the outer query from IQueryable.Method<T> to IEnumerable.Method<T>
// Too much long :)
// Note that this Queryable is executed in "local" (the AsQueryable<T> method is nearly
// useless... The second time in my life I was able to use it for something)
IQueryable <TInner> queryable = Queryable.AsQueryable(enumerable2);
// We rebuild a new expression by changing the "old" inner parameter
// of the MethodCallExpression with the queryable we just
// built
Expression expression2 = new SimpleExpressionReplacer {
Call = call, Queryable = queryable
}.Visit(Query.Expression);
// We "execute" locally the whole query through a second
// "outer" instance of the EnumerableQuery (this class is
// the class that "implements" the "fake-magic" of AsQueryable)
EnumerableQuery <T> query2 = new EnumerableQuery <T>(expression2);
// And we return an enumerator to it
return(query2.AsEnumerable());
}
public void should_read_memory_stream()
{
IEnumerable <byte> source = series(0, 4, i => (byte)i);
byte[] arr = new FakeEnumerable(
new MemoryStream(array(source)), 1)
.SelectMany(b => b)
.ToArray();
Assert.IsTrue(source.SequenceEqual(arr));
}
