|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
namespace System.Linq
{
public static partial class AsyncEnumerable
{
/// <summary>Returns the minimum value in a generic sequence.</summary>
/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
/// <param name="source">A sequence of values to determine the minimum value of.</param>
/// <param name="comparer">The <see cref="IComparer{T}" /> to compare values.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
/// <returns>The minimum value in the sequence.</returns>
/// <exception cref="ArgumentNullException"><paramref name="source" /> is <see langword="null" />.</exception>
/// <exception cref="ArgumentException">No object in <paramref name="source" /> implements the <see cref="IComparable" /> or <see cref="IComparable{T}" /> interface.</exception>
/// <remarks>
/// <para>If type <typeparamref name="TSource" /> implements <see cref="IComparable{T}" />, the <see cref="MinAsync{TSource}(IAsyncEnumerable{TSource}, IComparer{TSource}?, CancellationToken)" /> method uses that implementation to compare values. Otherwise, if type <typeparamref name="TSource" /> implements <see cref="IComparable" />, that implementation is used to compare values.</para>
/// <para>If <typeparamref name="TSource" /> is a reference type and the source sequence is empty or contains only values that are <see langword="null" />, this method returns <see langword="null" />.</para>
/// </remarks>
public static ValueTask<TSource?> MinAsync<TSource>(
this IAsyncEnumerable<TSource> source,
IComparer<TSource>? comparer = null,
CancellationToken cancellationToken = default)
{
ArgumentNullException.ThrowIfNull(source);
comparer ??= Comparer<TSource>.Default;
// Special-case float/double/float?/double? to maintain compatibility
// with System.Linq.Enumerable implementations.
#pragma warning disable CA2012 // Use ValueTasks correctly
if (typeof(TSource) == typeof(float) && comparer == Comparer<TSource>.Default)
{
return (ValueTask<TSource?>)(object)MinAsync((IAsyncEnumerable<float>)(object)source, cancellationToken);
}
if (typeof(TSource) == typeof(double) && comparer == Comparer<TSource>.Default)
{
return (ValueTask<TSource?>)(object)MinAsync((IAsyncEnumerable<double>)(object)source, cancellationToken);
}
if (typeof(TSource) == typeof(float?) && comparer == Comparer<TSource>.Default)
{
return (ValueTask<TSource?>)(object)MinAsync((IAsyncEnumerable<float?>)(object)source, cancellationToken);
}
if (typeof(TSource) == typeof(double?) && comparer == Comparer<TSource>.Default)
{
return (ValueTask<TSource?>)(object)MinAsync((IAsyncEnumerable<double?>)(object)source, cancellationToken);
}
#pragma warning restore CA2012
return Impl(source, comparer, cancellationToken);
static async ValueTask<TSource?> Impl(IAsyncEnumerable<TSource> source, IComparer<TSource> comparer, CancellationToken cancellationToken)
{
await using IAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
TSource? value = default;
if (default(TSource) is null)
{
do
{
if (!await e.MoveNextAsync())
{
return value;
}
value = e.Current;
}
while (value is null);
while (await e.MoveNextAsync())
{
TSource next = e.Current;
if (next is not null && comparer.Compare(next, value) < 0)
{
value = next;
}
}
}
else
{
if (!await e.MoveNextAsync())
{
ThrowHelper.ThrowNoElementsException();
}
value = e.Current;
if (comparer == Comparer<TSource>.Default)
{
while (await e.MoveNextAsync())
{
TSource next = e.Current;
if (Comparer<TSource>.Default.Compare(next, value) < 0)
{
value = next;
}
}
}
else
{
while (await e.MoveNextAsync())
{
TSource next = e.Current;
if (comparer.Compare(next, value) < 0)
{
value = next;
}
}
}
}
return value;
}
}
/// <summary>Returns the minimum value in a sequence of values.</summary>
/// <param name="source">A sequence of values to determine the minimum value of.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
/// <returns>The minimum value in the sequence.</returns>
private static async ValueTask<float> MinAsync(
IAsyncEnumerable<float> source,
CancellationToken cancellationToken)
{
await using IAsyncEnumerator<float> e = source.GetAsyncEnumerator(cancellationToken);
if (!await e.MoveNextAsync())
{
ThrowHelper.ThrowNoElementsException();
}
float value = e.Current;
if (float.IsNaN(value))
{
return value;
}
while (await e.MoveNextAsync())
{
float x = e.Current;
if (x < value)
{
value = x;
}
// Normally NaN < anything is false, as is anything < NaN
// However, this leads to some irksome outcomes in Min and Max.
// If we use those semantics then Min(NaN, 5.0) is NaN, but
// Min(5.0, NaN) is 5.0! To fix this, we impose a total
// ordering where NaN is smaller than every value, including
// negative infinity. Not testing for NaN therefore isn't an option, but since we
// can't find a smaller value, we can short-circuit.
else if (float.IsNaN(x))
{
return x;
}
}
return value;
}
/// <summary>Returns the minimum value in a sequence of values.</summary>
/// <param name="source">A sequence of values to determine the minimum value of.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
/// <returns>The minimum value in the sequence.</returns>
private static async ValueTask<double> MinAsync(
IAsyncEnumerable<double> source,
CancellationToken cancellationToken)
{
await using IAsyncEnumerator<double> e = source.GetAsyncEnumerator(cancellationToken);
if (!await e.MoveNextAsync())
{
ThrowHelper.ThrowNoElementsException();
}
double value = e.Current;
if (double.IsNaN(value))
{
return value;
}
while (await e.MoveNextAsync())
{
double x = e.Current;
if (x < value)
{
value = x;
}
// Normally NaN < anything is false, as is anything < NaN
// However, this leads to some irksome outcomes in Min and Max.
// If we use those semantics then Min(NaN, 5.0) is NaN, but
// Min(5.0, NaN) is 5.0! To fix this, we impose a total
// ordering where NaN is smaller than every value, including
// negative infinity. Not testing for NaN therefore isn't an option, but since we
// can't find a smaller value, we can short-circuit.
else if (double.IsNaN(x))
{
return x;
}
}
return value;
}
/// <summary>Returns the minimum value in a sequence of nullable values.</summary>
/// <param name="source">A sequence of nullable values to determine the minimum value of.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
/// <returns>The minimum value in the sequence.</returns>
private static async ValueTask<float?> MinAsync(
IAsyncEnumerable<float?> source,
CancellationToken cancellationToken)
{
float? value = null;
await foreach (float? x in source.WithCancellation(cancellationToken))
{
if (x is null)
{
continue;
}
if (value == null || x < value || float.IsNaN(x.GetValueOrDefault()))
{
value = x;
}
}
return value;
}
/// <summary>Returns the minimum value in a sequence of nullable values.</summary>
/// <param name="source">A sequence of nullable values to determine the minimum value of.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
/// <returns>The minimum value in the sequence.</returns>
private static async ValueTask<double?> MinAsync(
IAsyncEnumerable<double?> source,
CancellationToken cancellationToken)
{
double? value = null;
await foreach (double? x in source.WithCancellation(cancellationToken))
{
if (x is null)
{
continue;
}
if (value == null || x < value || double.IsNaN(x.GetValueOrDefault()))
{
value = x;
}
}
return value;
}
}
}
|