コード例 #1
0
                public async Task <bool> MoveNext(CancellationToken cancellationToken)
                {
                    if (_sourceEnumerator == null)
                    {
                        _sourceEnumerator = _groupJoinAsyncEnumerable._source.GetEnumerator();
                        _hasRows          = await _sourceEnumerator.MoveNext();
                    }

                    if (_hasRows)
                    {
                        var outerQueryResultScope = _sourceEnumerator.Current;

                        var innerQueryResultScopes = new List <QueryResultScope <TResult> >();

                        if (_sourceEnumerator.Current.UntypedResult == null)
                        {
                            _hasRows = await _sourceEnumerator.MoveNext();
                        }
                        else
                        {
                            var parentScope = _sourceEnumerator.Current.ParentScope;

                            while (_hasRows)
                            {
                                innerQueryResultScopes.Add((QueryResultScope <TResult>)_sourceEnumerator.Current);

                                _hasRows = await _sourceEnumerator.MoveNext();

                                if (_hasRows &&
                                    !ReferenceEquals(
                                        parentScope.UntypedResult,
                                        _sourceEnumerator.Current.ParentScope.UntypedResult))
                                {
                                    break;
                                }
                            }
                        }

                        Current
                            = _groupJoinAsyncEnumerable._resultSelector(
                                  outerQueryResultScope, AsyncLinqOperatorProvider.ToAsyncEnumerable(innerQueryResultScopes));

                        return(true);
                    }

                    return(false);
                }
コード例 #2
0
                public async Task <bool> MoveNext(CancellationToken cancellationToken)
                {
                    cancellationToken.ThrowIfCancellationRequested();

                    if (_sourceEnumerator == null)
                    {
                        _sourceEnumerator = _groupJoinAsyncEnumerable._source.GetEnumerator();
                        _hasNext          = await _sourceEnumerator.MoveNext();
                    }

                    if (_hasNext)
                    {
                        var outer
                            = _groupJoinAsyncEnumerable._outerShaper
                              .Shape(_groupJoinAsyncEnumerable._queryContext, _sourceEnumerator.Current);

                        var inner
                            = _groupJoinAsyncEnumerable._innerShaper
                              .Shape(_groupJoinAsyncEnumerable._queryContext, _sourceEnumerator.Current);

                        var inners = new List <TInner>();

                        if (inner == null)
                        {
                            Current
                                = _groupJoinAsyncEnumerable._resultSelector(
                                      outer, AsyncLinqOperatorProvider.ToAsyncEnumerable(inners));

                            _hasNext = await _sourceEnumerator.MoveNext();

                            return(true);
                        }

                        var currentGroupKey = _groupJoinAsyncEnumerable._innerKeySelector(inner);

                        inners.Add(inner);

                        while (true)
                        {
                            _hasNext = await _sourceEnumerator.MoveNext();

                            if (!_hasNext)
                            {
                                break;
                            }

                            inner
                                = _groupJoinAsyncEnumerable._innerShaper
                                  .Shape(_groupJoinAsyncEnumerable._queryContext, _sourceEnumerator.Current);

                            if (inner == null)
                            {
                                break;
                            }

                            var innerKey = _groupJoinAsyncEnumerable._innerKeySelector(inner);

                            if (!_comparer.Equals(currentGroupKey, innerKey))
                            {
                                break;
                            }

                            inners.Add(inner);
                        }

                        Current
                            = _groupJoinAsyncEnumerable._resultSelector(
                                  outer, AsyncLinqOperatorProvider.ToAsyncEnumerable(inners));

                        return(true);
                    }

                    return(false);
                }