示例#1
0
        internal static async Task <HashSet <T> > ToHashSetAsync <T>(this IDbAsyncEnumerable source, CancellationToken cancellationToken)
        {
            var hashSet = new HashSet <T>();
            await TaskExtensions.WithCurrentCulture(IDbAsyncEnumerableExtensions.ForEachAsync(source, (Action <object>)(e => hashSet.Add((T)e)), cancellationToken));

            return(hashSet);
        }
示例#2
0
        public override Db.OeAsyncEnumerator ExecuteEnumerator(Object dataContext, OeQueryContext queryContext, CancellationToken cancellationToken)
        {
            Expression           expression;
            MethodCallExpression countExpression = null;
            IQueryable           query           = queryContext.EntitySetAdapter.GetEntitySet(dataContext);

            if (base.QueryCache.AllowCache)
            {
                expression = GetFromCache(queryContext, (T)dataContext, base.QueryCache, out countExpression);
            }
            else
            {
                expression = queryContext.CreateExpression(new OeConstantToVariableVisitor());
                expression = new EnumerableToQuerableVisitor().Visit(expression);
                expression = queryContext.TranslateSource(dataContext, expression);

                if (queryContext.ODataUri.QueryCount.GetValueOrDefault())
                {
                    countExpression = OeQueryContext.CreateCountExpression(expression);
                }
            }

            IDbAsyncEnumerable asyncEnumerable = (IDbAsyncEnumerable)query.Provider.CreateQuery(expression);

            Db.OeAsyncEnumerator asyncEnumerator = new OeEf6AsyncEnumerator(asyncEnumerable.GetAsyncEnumerator(), cancellationToken);
            if (countExpression != null)
            {
                query = queryContext.EntitySetAdapter.GetEntitySet(dataContext);
                asyncEnumerator.Count = query.Provider.Execute <int>(countExpression);
            }

            return(base.OperationAdapter.ApplyBoundFunction(asyncEnumerator, queryContext));
        }
        public override IAsyncEnumerable <Object> Execute(Object dataContext, OeQueryContext queryContext)
        {
            Expression           expression;
            MethodCallExpression countExpression = null;
            IQueryable           query           = queryContext.EntitySetAdapter.GetEntitySet(dataContext);

            if (base.QueryCache.AllowCache)
            {
                expression = GetFromCache(queryContext, (T)dataContext, base.QueryCache, out countExpression);
            }
            else
            {
                expression = queryContext.CreateExpression(new OeConstantToVariableVisitor());
                expression = new OeEf6EnumerableToQuerableVisitor().Visit(expression);
                expression = queryContext.TranslateSource(dataContext, expression);

                if (queryContext.IsQueryCount())
                {
                    countExpression = queryContext.CreateCountExpression(expression);
                }
            }

            IDbAsyncEnumerable        asyncEnumerable = (IDbAsyncEnumerable)query.Provider.CreateQuery(expression);
            IAsyncEnumerable <Object> asyncEnumerator = new OeEf6AsyncEnumerator(asyncEnumerable);

            if (countExpression != null)
            {
                query = queryContext.EntitySetAdapter.GetEntitySet(dataContext);
                queryContext.TotalCountOfItems = query.Provider.Execute <int>(countExpression);
            }

            return(asyncEnumerator);
        }
 internal static Task <TResult> ExecuteSingleAsync <TResult>(
     IDbAsyncEnumerable <TResult> query,
     Expression queryRoot,
     CancellationToken cancellationToken)
 {
     return(ObjectQueryProvider.GetAsyncElementFunction <TResult>(queryRoot)(query, cancellationToken));
 }
        public IDbAsyncEnumerator GetAsyncEnumerator()
        {
            IDbAsyncEnumerable asyncEnumerable = inner as IDbAsyncEnumerable;

            if (asyncEnumerable == null)
            {
                throw new InvalidOperationException("The source IQueryable doesn't implement IDbAsyncEnumerable.");
            }
            return(asyncEnumerable.GetAsyncEnumerator());
        }
示例#6
0
        private static IDbAsyncEnumerable <T> AsDbAsyncEnumerable <T>(this IQueryable <T> source)
        {
            IDbAsyncEnumerable <T> dbAsyncEnumerable = source as IDbAsyncEnumerable <T>;

            if (dbAsyncEnumerable != null)
            {
                return(dbAsyncEnumerable);
            }

            throw new InvalidOperationException("IQueryable not async!");
        }
示例#7
0
 internal static async Task ForEachAsync(this IDbAsyncEnumerable source, Action <object> action, CancellationToken cancellationToken)
 {
     cancellationToken.ThrowIfCancellationRequested();
     using (IDbAsyncEnumerator asyncEnumerator = source.GetAsyncEnumerator())
     {
         if (await TaskExtensions.WithCurrentCulture <bool>(asyncEnumerator.MoveNextAsync(cancellationToken)))
         {
             Task <bool> moveNextTask;
             do
             {
                 cancellationToken.ThrowIfCancellationRequested();
                 object current = asyncEnumerator.Current;
                 moveNextTask = asyncEnumerator.MoveNextAsync(cancellationToken);
                 action(current);
             }while (await TaskExtensions.WithCurrentCulture <bool>(moveNextTask));
         }
     }
 }
        static async Task <IEnumerable> EnumerateAsync <TEntity>(IDbAsyncEnumerable enumerable, CancellationToken cancellationToken)
        {
            using (var iterator = enumerable.GetAsyncEnumerator())
            {
                if (!await iterator.MoveNextAsync(cancellationToken).ConfigureAwait(false))
                {
                    return(Array.Empty <TEntity>());
                }

                var results = new List <TEntity>()
                {
                    (TEntity)iterator.Current
                };

                while (await iterator.MoveNextAsync(cancellationToken).ConfigureAwait(false))
                {
                    results.Add((TEntity)iterator.Current);
                }

                return(results);
            }
        }
示例#9
0
        public static async ValueTask <IReadOnlyCollection <T> > EnumerateAsyncEnumerable <T>(IDbAsyncEnumerable <T> asyncEnumerable, int estimatedResultCount, CancellationToken cancellationToken)
        {
            using (var enumerator = asyncEnumerable.GetAsyncEnumerator())
            {
                List <T> result = new List <T>(capacity: estimatedResultCount);
                while (await enumerator.MoveNextAsync(cancellationToken).ConfigureAwait(false))
                {
                    result.Add(enumerator.Current);
                }

                return(result);
            }
        }
示例#10
0
 internal static Task <HashSet <T> > ToHashSetAsync <T>(this IDbAsyncEnumerable source)
 {
     return(IDbAsyncEnumerableExtensions.ToHashSetAsync <T>(source, CancellationToken.None));
 }
示例#11
0
 public OeEf6AsyncEnumerator(IDbAsyncEnumerable asyncEnumerable)
 {
     _asyncEnumerator = asyncEnumerable.GetAsyncEnumerator();
 }