Exemplos de AsyncEnumerableHelpers.ToArrayWithLength em C# (CSharp)

Exemplo n.º 1

        public async ValueTask <TElement[]> ToArrayAsync(CancellationToken cancellationToken)
        {
            var elements = await AsyncEnumerableHelpers.ToArrayWithLength(_source, cancellationToken).ConfigureAwait(false);

            var count = elements.Length;

            if (count == 0)
            {
#if NO_ARRAY_EMPTY
                return(EmptyArray <TElement> .Value);
#else
                return(Array.Empty <TElement>());
#endif
            }

            var array = elements.Array;

            var map = await SortedMap(array, count, cancellationToken).ConfigureAwait(false);

            var result = new TElement[count];

            for (var i = 0; i < result.Length; i++)
            {
                result[i] = array[map[i]];
            }

            return(result);
        }

Exemplo n.º 2

        public ValueTask <Maybe <TElement> > TryGetElementAtAsync(int index, CancellationToken cancellationToken)
        {
            if (index == 0)
            {
                return(TryGetFirstAsync(cancellationToken));
            }

            if (index > 0)
            {
                return(Core());

                async ValueTask <Maybe <TElement> > Core()
                {
                    var elements = await AsyncEnumerableHelpers.ToArrayWithLength(_source, cancellationToken).ConfigureAwait(false);

                    var count = elements.Length;

                    if (index < count)
                    {
                        var sorter = GetAsyncEnumerableSorter(cancellationToken);

                        var element = await sorter.ElementAt(elements.Array, count, index).ConfigureAwait(false);

                        return(new Maybe <TElement>(element));
                    }

                    return(new Maybe <TElement>());
                }
            }

            return(new ValueTask <Maybe <TElement> >(new Maybe <TElement>()));
        }

Exemplo n.º 3

        internal async ValueTask <Maybe <TElement> > TryGetLastAsync(int minIndexInclusive, int maxIndexInclusive, CancellationToken cancellationToken)
        {
            var elements = await AsyncEnumerableHelpers.ToArrayWithLength(_source, cancellationToken).ConfigureAwait(false);

            var count = elements.Length;

            if (minIndexInclusive >= count)
            {
                return(new Maybe <TElement>());
            }

            var array = elements.Array;

            TElement last;

            if (maxIndexInclusive < count - 1)
            {
                var sorter = GetAsyncEnumerableSorter(cancellationToken);

                last = await sorter.ElementAt(array, count, maxIndexInclusive).ConfigureAwait(false);
            }
            else
            {
                last = await Last(array, count, cancellationToken).ConfigureAwait(false);
            }

            return(new Maybe <TElement>(last));
        }

Exemplo n.º 4

        internal async ValueTask <TElement[]> ToArrayAsync(int minIndexInclusive, int maxIndexInclusive, CancellationToken cancellationToken)
        {
            var elements = await AsyncEnumerableHelpers.ToArrayWithLength(_source, cancellationToken).ConfigureAwait(false);

            var count = elements.Length;

            if (count <= minIndexInclusive)
            {
#if NO_ARRAY_EMPTY
                return(EmptyArray <TElement> .Value);
#else
                return(Array.Empty <TElement>());
#endif
            }

            if (count <= maxIndexInclusive)
            {
                maxIndexInclusive = count - 1;
            }

            var array = elements.Array;

            if (minIndexInclusive == maxIndexInclusive)
            {
                var sorter = GetAsyncEnumerableSorter(cancellationToken);

                var element = await sorter.ElementAt(array, count, minIndexInclusive).ConfigureAwait(false);

                return(new TElement[] { element });
            }

            var map = await SortedMap(array, count, minIndexInclusive, maxIndexInclusive, cancellationToken).ConfigureAwait(false);

            var result = new TElement[maxIndexInclusive - minIndexInclusive + 1];

            for (var i = 0; minIndexInclusive <= maxIndexInclusive; i++)
            {
                result[i] = array[map[minIndexInclusive++]];
            }

            return(result);
        }

Exemplo n.º 5

        internal async ValueTask <List <TElement> > ToListAsync(int minIndexInclusive, int maxIndexInclusive, CancellationToken cancellationToken)
        {
            var elements = await AsyncEnumerableHelpers.ToArrayWithLength(_source, cancellationToken).ConfigureAwait(false);

            var count = elements.Length;

            if (count <= minIndexInclusive)
            {
                return(new List <TElement>(0));
            }

            if (count <= maxIndexInclusive)
            {
                maxIndexInclusive = count - 1;
            }

            var array = elements.Array;

            if (minIndexInclusive == maxIndexInclusive)
            {
                var sorter = GetAsyncEnumerableSorter(cancellationToken);

                var element = await sorter.ElementAt(array, count, minIndexInclusive).ConfigureAwait(false);

                return(new List <TElement>(1)
                {
                    element
                });
            }

            var map = await SortedMap(array, count, minIndexInclusive, maxIndexInclusive, cancellationToken).ConfigureAwait(false);

            var list = new List <TElement>(maxIndexInclusive - minIndexInclusive + 1);

            while (minIndexInclusive <= maxIndexInclusive)
            {
                list.Add(array[map[minIndexInclusive++]]);
            }

            return(list);
        }

Exemplo n.º 6

        public async ValueTask <List <TElement> > ToListAsync(CancellationToken cancellationToken)
        {
            var elements = await AsyncEnumerableHelpers.ToArrayWithLength(_source, cancellationToken).ConfigureAwait(false);

            var count = elements.Length;

            if (count == 0)
            {
                return(new List <TElement>(capacity: 0));
            }

            var array = elements.Array;

            var map = await SortedMap(array, count, cancellationToken).ConfigureAwait(false);

            var result = new List <TElement>(count);

            for (var i = 0; i < count; i++)
            {
                result.Add(array[map[i]]);
            }

            return(result);
        }