Select.cs 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705
  1. // Licensed to the .NET Foundation under one or more agreements.
  2. // The .NET Foundation licenses this file to you under the MIT License.
  3. // See the LICENSE file in the project root for more information.
  4. using System.Collections.Generic;
  5. using System.Threading;
  6. using System.Threading.Tasks;
  7. namespace System.Linq
  8. {
  9. public static partial class AsyncEnumerable
  10. {
  11. /// <summary>
  12. /// Projects each element of an async-enumerable sequence into a new form.
  13. /// </summary>
  14. /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
  15. /// <typeparam name="TResult">The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence.</typeparam>
  16. /// <param name="source">A sequence of elements to invoke a transform function on.</param>
  17. /// <param name="selector">A transform function to apply to each source element.</param>
  18. /// <returns>An async-enumerable sequence whose elements are the result of invoking the transform function on each element of source.</returns>
  19. /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
  20. public static IAsyncEnumerable<TResult> Select<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, TResult> selector)
  21. {
  22. if (source == null)
  23. throw Error.ArgumentNull(nameof(source));
  24. if (selector == null)
  25. throw Error.ArgumentNull(nameof(selector));
  26. return source switch
  27. {
  28. AsyncIterator<TSource> iterator => iterator.Select(selector),
  29. IList<TSource> list => new SelectIListIterator<TSource, TResult>(list, selector),
  30. _ => new SelectEnumerableAsyncIterator<TSource, TResult>(source, selector),
  31. };
  32. }
  33. /// <summary>
  34. /// Projects each element of an async-enumerable sequence into a new form by incorporating the element's index.
  35. /// </summary>
  36. /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
  37. /// <typeparam name="TResult">The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence.</typeparam>
  38. /// <param name="source">A sequence of elements to invoke a transform function on.</param>
  39. /// <param name="selector">A transform function to apply to each source element; the second parameter of the function represents the index of the source element.</param>
  40. /// <returns>An async-enumerable sequence whose elements are the result of invoking the transform function on each element of source.</returns>
  41. /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
  42. public static IAsyncEnumerable<TResult> Select<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, TResult> selector)
  43. {
  44. if (source == null)
  45. throw Error.ArgumentNull(nameof(source));
  46. if (selector == null)
  47. throw Error.ArgumentNull(nameof(selector));
  48. #if HAS_ASYNC_ENUMERABLE_CANCELLATION
  49. return Core();
  50. async IAsyncEnumerable<TResult> Core([System.Runtime.CompilerServices.EnumeratorCancellation]CancellationToken cancellationToken = default)
  51. #else
  52. return Create(Core);
  53. async IAsyncEnumerator<TResult> Core(CancellationToken cancellationToken)
  54. #endif
  55. {
  56. var index = -1;
  57. await foreach (var element in source.WithCancellation(cancellationToken).ConfigureAwait(false))
  58. {
  59. checked
  60. {
  61. index++;
  62. }
  63. yield return selector(element, index);
  64. }
  65. }
  66. }
  67. internal static IAsyncEnumerable<TResult> SelectAwaitCore<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TResult>> selector)
  68. {
  69. if (source == null)
  70. throw Error.ArgumentNull(nameof(source));
  71. if (selector == null)
  72. throw Error.ArgumentNull(nameof(selector));
  73. return source switch
  74. {
  75. AsyncIterator<TSource> iterator => iterator.Select(selector),
  76. IList<TSource> list => new SelectIListIteratorWithTask<TSource, TResult>(list, selector),
  77. _ => new SelectEnumerableAsyncIteratorWithTask<TSource, TResult>(source, selector),
  78. };
  79. }
  80. #if !NO_DEEP_CANCELLATION
  81. internal static IAsyncEnumerable<TResult> SelectAwaitWithCancellationCore<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TResult>> selector)
  82. {
  83. if (source == null)
  84. throw Error.ArgumentNull(nameof(source));
  85. if (selector == null)
  86. throw Error.ArgumentNull(nameof(selector));
  87. return source switch
  88. {
  89. AsyncIterator<TSource> iterator => iterator.Select(selector),
  90. IList<TSource> list => new SelectIListIteratorWithTaskAndCancellation<TSource, TResult>(list, selector),
  91. _ => new SelectEnumerableAsyncIteratorWithTaskAndCancellation<TSource, TResult>(source, selector),
  92. };
  93. }
  94. #endif
  95. internal static IAsyncEnumerable<TResult> SelectAwaitCore<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<TResult>> selector)
  96. {
  97. if (source == null)
  98. throw Error.ArgumentNull(nameof(source));
  99. if (selector == null)
  100. throw Error.ArgumentNull(nameof(selector));
  101. #if HAS_ASYNC_ENUMERABLE_CANCELLATION
  102. return Core();
  103. async IAsyncEnumerable<TResult> Core([System.Runtime.CompilerServices.EnumeratorCancellation]CancellationToken cancellationToken = default)
  104. #else
  105. return Create(Core);
  106. async IAsyncEnumerator<TResult> Core(CancellationToken cancellationToken)
  107. #endif
  108. {
  109. var index = -1;
  110. await foreach (var element in source.WithCancellation(cancellationToken).ConfigureAwait(false))
  111. {
  112. checked
  113. {
  114. index++;
  115. }
  116. yield return await selector(element, index).ConfigureAwait(false);
  117. }
  118. }
  119. }
  120. #if !NO_DEEP_CANCELLATION
  121. internal static IAsyncEnumerable<TResult> SelectAwaitWithCancellationCore<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<TResult>> selector)
  122. {
  123. if (source == null)
  124. throw Error.ArgumentNull(nameof(source));
  125. if (selector == null)
  126. throw Error.ArgumentNull(nameof(selector));
  127. #if HAS_ASYNC_ENUMERABLE_CANCELLATION
  128. return Core();
  129. async IAsyncEnumerable<TResult> Core([System.Runtime.CompilerServices.EnumeratorCancellation]CancellationToken cancellationToken = default)
  130. #else
  131. return Create(Core);
  132. async IAsyncEnumerator<TResult> Core(CancellationToken cancellationToken)
  133. #endif
  134. {
  135. var index = -1;
  136. await foreach (var element in source.WithCancellation(cancellationToken).ConfigureAwait(false))
  137. {
  138. checked
  139. {
  140. index++;
  141. }
  142. yield return await selector(element, index, cancellationToken).ConfigureAwait(false);
  143. }
  144. }
  145. }
  146. #endif
  147. internal sealed class SelectEnumerableAsyncIterator<TSource, TResult> : AsyncIterator<TResult>
  148. {
  149. private readonly Func<TSource, TResult> _selector;
  150. private readonly IAsyncEnumerable<TSource> _source;
  151. private IAsyncEnumerator<TSource>? _enumerator;
  152. public SelectEnumerableAsyncIterator(IAsyncEnumerable<TSource> source, Func<TSource, TResult> selector)
  153. {
  154. _source = source;
  155. _selector = selector;
  156. }
  157. public override AsyncIteratorBase<TResult> Clone()
  158. {
  159. return new SelectEnumerableAsyncIterator<TSource, TResult>(_source, _selector);
  160. }
  161. public override async ValueTask DisposeAsync()
  162. {
  163. if (_enumerator != null)
  164. {
  165. await _enumerator.DisposeAsync().ConfigureAwait(false);
  166. _enumerator = null;
  167. }
  168. await base.DisposeAsync().ConfigureAwait(false);
  169. }
  170. public override IAsyncEnumerable<TResult1> Select<TResult1>(Func<TResult, TResult1> selector)
  171. {
  172. return new SelectEnumerableAsyncIterator<TSource, TResult1>(_source, CombineSelectors(_selector, selector));
  173. }
  174. protected override async ValueTask<bool> MoveNextCore()
  175. {
  176. switch (_state)
  177. {
  178. case AsyncIteratorState.Allocated:
  179. _enumerator = _source.GetAsyncEnumerator(_cancellationToken);
  180. _state = AsyncIteratorState.Iterating;
  181. goto case AsyncIteratorState.Iterating;
  182. case AsyncIteratorState.Iterating:
  183. if (await _enumerator!.MoveNextAsync().ConfigureAwait(false))
  184. {
  185. _current = _selector(_enumerator.Current);
  186. return true;
  187. }
  188. break;
  189. }
  190. await DisposeAsync().ConfigureAwait(false);
  191. return false;
  192. }
  193. }
  194. internal sealed class SelectIListIterator<TSource, TResult> : AsyncIterator<TResult>, IAsyncIListProvider<TResult>
  195. {
  196. private readonly Func<TSource, TResult> _selector;
  197. private readonly IList<TSource> _source;
  198. private IEnumerator<TSource>? _enumerator;
  199. public SelectIListIterator(IList<TSource> source, Func<TSource, TResult> selector)
  200. {
  201. _source = source;
  202. _selector = selector;
  203. }
  204. public override AsyncIteratorBase<TResult> Clone()
  205. {
  206. return new SelectIListIterator<TSource, TResult>(_source, _selector);
  207. }
  208. public override async ValueTask DisposeAsync()
  209. {
  210. if (_enumerator != null)
  211. {
  212. _enumerator.Dispose();
  213. _enumerator = null;
  214. }
  215. await base.DisposeAsync().ConfigureAwait(false);
  216. }
  217. public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
  218. {
  219. if (onlyIfCheap)
  220. {
  221. return new ValueTask<int>(-1);
  222. }
  223. cancellationToken.ThrowIfCancellationRequested();
  224. var count = 0;
  225. foreach (var item in _source)
  226. {
  227. _selector(item);
  228. checked
  229. {
  230. count++;
  231. }
  232. }
  233. return new ValueTask<int>(count);
  234. }
  235. public override IAsyncEnumerable<TResult1> Select<TResult1>(Func<TResult, TResult1> selector)
  236. {
  237. return new SelectIListIterator<TSource, TResult1>(_source, CombineSelectors(_selector, selector));
  238. }
  239. public ValueTask<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
  240. {
  241. cancellationToken.ThrowIfCancellationRequested();
  242. var n = _source.Count;
  243. var res = new TResult[n];
  244. for (var i = 0; i < n; i++)
  245. {
  246. res[i] = _selector(_source[i]);
  247. }
  248. return new ValueTask<TResult[]>(res);
  249. }
  250. public ValueTask<List<TResult>> ToListAsync(CancellationToken cancellationToken)
  251. {
  252. cancellationToken.ThrowIfCancellationRequested();
  253. var n = _source.Count;
  254. var res = new List<TResult>(n);
  255. for (var i = 0; i < n; i++)
  256. {
  257. res.Add(_selector(_source[i]));
  258. }
  259. return new ValueTask<List<TResult>>(res);
  260. }
  261. protected override async ValueTask<bool> MoveNextCore()
  262. {
  263. switch (_state)
  264. {
  265. case AsyncIteratorState.Allocated:
  266. _enumerator = _source.GetEnumerator();
  267. _state = AsyncIteratorState.Iterating;
  268. goto case AsyncIteratorState.Iterating;
  269. case AsyncIteratorState.Iterating:
  270. if (_enumerator!.MoveNext())
  271. {
  272. _current = _selector(_enumerator.Current);
  273. return true;
  274. }
  275. await DisposeAsync().ConfigureAwait(false);
  276. break;
  277. }
  278. return false;
  279. }
  280. }
  281. internal sealed class SelectEnumerableAsyncIteratorWithTask<TSource, TResult> : AsyncIterator<TResult>
  282. {
  283. private readonly Func<TSource, ValueTask<TResult>> _selector;
  284. private readonly IAsyncEnumerable<TSource> _source;
  285. private IAsyncEnumerator<TSource>? _enumerator;
  286. public SelectEnumerableAsyncIteratorWithTask(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TResult>> selector)
  287. {
  288. _source = source;
  289. _selector = selector;
  290. }
  291. public override AsyncIteratorBase<TResult> Clone()
  292. {
  293. return new SelectEnumerableAsyncIteratorWithTask<TSource, TResult>(_source, _selector);
  294. }
  295. public override async ValueTask DisposeAsync()
  296. {
  297. if (_enumerator != null)
  298. {
  299. await _enumerator.DisposeAsync().ConfigureAwait(false);
  300. _enumerator = null;
  301. }
  302. await base.DisposeAsync().ConfigureAwait(false);
  303. }
  304. public override IAsyncEnumerable<TResult1> Select<TResult1>(Func<TResult, ValueTask<TResult1>> selector)
  305. {
  306. return new SelectEnumerableAsyncIteratorWithTask<TSource, TResult1>(_source, CombineSelectors(_selector, selector));
  307. }
  308. protected override async ValueTask<bool> MoveNextCore()
  309. {
  310. switch (_state)
  311. {
  312. case AsyncIteratorState.Allocated:
  313. _enumerator = _source.GetAsyncEnumerator(_cancellationToken);
  314. _state = AsyncIteratorState.Iterating;
  315. goto case AsyncIteratorState.Iterating;
  316. case AsyncIteratorState.Iterating:
  317. if (await _enumerator!.MoveNextAsync().ConfigureAwait(false))
  318. {
  319. _current = await _selector(_enumerator.Current).ConfigureAwait(false);
  320. return true;
  321. }
  322. break;
  323. }
  324. await DisposeAsync().ConfigureAwait(false);
  325. return false;
  326. }
  327. }
  328. #if !NO_DEEP_CANCELLATION
  329. internal sealed class SelectEnumerableAsyncIteratorWithTaskAndCancellation<TSource, TResult> : AsyncIterator<TResult>
  330. {
  331. private readonly Func<TSource, CancellationToken, ValueTask<TResult>> _selector;
  332. private readonly IAsyncEnumerable<TSource> _source;
  333. private IAsyncEnumerator<TSource>? _enumerator;
  334. public SelectEnumerableAsyncIteratorWithTaskAndCancellation(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TResult>> selector)
  335. {
  336. _source = source;
  337. _selector = selector;
  338. }
  339. public override AsyncIteratorBase<TResult> Clone()
  340. {
  341. return new SelectEnumerableAsyncIteratorWithTaskAndCancellation<TSource, TResult>(_source, _selector);
  342. }
  343. public override async ValueTask DisposeAsync()
  344. {
  345. if (_enumerator != null)
  346. {
  347. await _enumerator.DisposeAsync().ConfigureAwait(false);
  348. _enumerator = null;
  349. }
  350. await base.DisposeAsync().ConfigureAwait(false);
  351. }
  352. public override IAsyncEnumerable<TResult1> Select<TResult1>(Func<TResult, CancellationToken, ValueTask<TResult1>> selector)
  353. {
  354. return new SelectEnumerableAsyncIteratorWithTaskAndCancellation<TSource, TResult1>(_source, CombineSelectors(_selector, selector));
  355. }
  356. protected override async ValueTask<bool> MoveNextCore()
  357. {
  358. switch (_state)
  359. {
  360. case AsyncIteratorState.Allocated:
  361. _enumerator = _source.GetAsyncEnumerator(_cancellationToken);
  362. _state = AsyncIteratorState.Iterating;
  363. goto case AsyncIteratorState.Iterating;
  364. case AsyncIteratorState.Iterating:
  365. if (await _enumerator!.MoveNextAsync().ConfigureAwait(false))
  366. {
  367. _current = await _selector(_enumerator.Current, _cancellationToken).ConfigureAwait(false);
  368. return true;
  369. }
  370. break;
  371. }
  372. await DisposeAsync().ConfigureAwait(false);
  373. return false;
  374. }
  375. }
  376. #endif
  377. // NB: LINQ to Objects implements IPartition<TResult> for this. However, it seems incorrect to do so in a trivial
  378. // manner where e.g. TryGetLast simply indexes into the list without running the selector for the first n - 1
  379. // elements in order to ensure side-effects. We should consider whether we want to follow this implementation
  380. // strategy or support IAsyncPartition<TResult> in a less efficient but more correct manner here.
  381. private sealed class SelectIListIteratorWithTask<TSource, TResult> : AsyncIterator<TResult>, IAsyncIListProvider<TResult>
  382. {
  383. private readonly Func<TSource, ValueTask<TResult>> _selector;
  384. private readonly IList<TSource> _source;
  385. private IEnumerator<TSource>? _enumerator;
  386. public SelectIListIteratorWithTask(IList<TSource> source, Func<TSource, ValueTask<TResult>> selector)
  387. {
  388. _source = source;
  389. _selector = selector;
  390. }
  391. public override AsyncIteratorBase<TResult> Clone()
  392. {
  393. return new SelectIListIteratorWithTask<TSource, TResult>(_source, _selector);
  394. }
  395. public override async ValueTask DisposeAsync()
  396. {
  397. if (_enumerator != null)
  398. {
  399. _enumerator.Dispose();
  400. _enumerator = null;
  401. }
  402. await base.DisposeAsync().ConfigureAwait(false);
  403. }
  404. public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
  405. {
  406. if (onlyIfCheap)
  407. {
  408. return new ValueTask<int>(-1);
  409. }
  410. return Core();
  411. async ValueTask<int> Core()
  412. {
  413. cancellationToken.ThrowIfCancellationRequested();
  414. var count = 0;
  415. foreach (var item in _source)
  416. {
  417. await _selector(item).ConfigureAwait(false);
  418. checked
  419. {
  420. count++;
  421. }
  422. }
  423. return count;
  424. }
  425. }
  426. public override IAsyncEnumerable<TResult1> Select<TResult1>(Func<TResult, ValueTask<TResult1>> selector)
  427. {
  428. return new SelectIListIteratorWithTask<TSource, TResult1>(_source, CombineSelectors(_selector, selector));
  429. }
  430. public async ValueTask<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
  431. {
  432. cancellationToken.ThrowIfCancellationRequested();
  433. var n = _source.Count;
  434. var res = new TResult[n];
  435. for (var i = 0; i < n; i++)
  436. {
  437. res[i] = await _selector(_source[i]).ConfigureAwait(false);
  438. }
  439. return res;
  440. }
  441. public async ValueTask<List<TResult>> ToListAsync(CancellationToken cancellationToken)
  442. {
  443. cancellationToken.ThrowIfCancellationRequested();
  444. var n = _source.Count;
  445. var res = new List<TResult>(n);
  446. for (var i = 0; i < n; i++)
  447. {
  448. res.Add(await _selector(_source[i]).ConfigureAwait(false));
  449. }
  450. return res;
  451. }
  452. protected override async ValueTask<bool> MoveNextCore()
  453. {
  454. switch (_state)
  455. {
  456. case AsyncIteratorState.Allocated:
  457. _enumerator = _source.GetEnumerator();
  458. _state = AsyncIteratorState.Iterating;
  459. goto case AsyncIteratorState.Iterating;
  460. case AsyncIteratorState.Iterating:
  461. if (_enumerator!.MoveNext())
  462. {
  463. _current = await _selector(_enumerator.Current).ConfigureAwait(false);
  464. return true;
  465. }
  466. break;
  467. }
  468. await DisposeAsync().ConfigureAwait(false);
  469. return false;
  470. }
  471. }
  472. #if !NO_DEEP_CANCELLATION
  473. private sealed class SelectIListIteratorWithTaskAndCancellation<TSource, TResult> : AsyncIterator<TResult>, IAsyncIListProvider<TResult>
  474. {
  475. private readonly Func<TSource, CancellationToken, ValueTask<TResult>> _selector;
  476. private readonly IList<TSource> _source;
  477. private IEnumerator<TSource>? _enumerator;
  478. public SelectIListIteratorWithTaskAndCancellation(IList<TSource> source, Func<TSource, CancellationToken, ValueTask<TResult>> selector)
  479. {
  480. _source = source;
  481. _selector = selector;
  482. }
  483. public override AsyncIteratorBase<TResult> Clone()
  484. {
  485. return new SelectIListIteratorWithTaskAndCancellation<TSource, TResult>(_source, _selector);
  486. }
  487. public override async ValueTask DisposeAsync()
  488. {
  489. if (_enumerator != null)
  490. {
  491. _enumerator.Dispose();
  492. _enumerator = null;
  493. }
  494. await base.DisposeAsync().ConfigureAwait(false);
  495. }
  496. public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
  497. {
  498. if (onlyIfCheap)
  499. {
  500. return new ValueTask<int>(-1);
  501. }
  502. return Core();
  503. async ValueTask<int> Core()
  504. {
  505. cancellationToken.ThrowIfCancellationRequested();
  506. var count = 0;
  507. foreach (var item in _source)
  508. {
  509. await _selector(item, cancellationToken).ConfigureAwait(false);
  510. checked
  511. {
  512. count++;
  513. }
  514. }
  515. return count;
  516. }
  517. }
  518. public override IAsyncEnumerable<TResult1> Select<TResult1>(Func<TResult, CancellationToken, ValueTask<TResult1>> selector)
  519. {
  520. return new SelectIListIteratorWithTaskAndCancellation<TSource, TResult1>(_source, CombineSelectors(_selector, selector));
  521. }
  522. public async ValueTask<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
  523. {
  524. cancellationToken.ThrowIfCancellationRequested();
  525. var n = _source.Count;
  526. var res = new TResult[n];
  527. for (var i = 0; i < n; i++)
  528. {
  529. res[i] = await _selector(_source[i], cancellationToken).ConfigureAwait(false);
  530. }
  531. return res;
  532. }
  533. public async ValueTask<List<TResult>> ToListAsync(CancellationToken cancellationToken)
  534. {
  535. cancellationToken.ThrowIfCancellationRequested();
  536. var n = _source.Count;
  537. var res = new List<TResult>(n);
  538. for (var i = 0; i < n; i++)
  539. {
  540. res.Add(await _selector(_source[i], cancellationToken).ConfigureAwait(false));
  541. }
  542. return res;
  543. }
  544. protected override async ValueTask<bool> MoveNextCore()
  545. {
  546. switch (_state)
  547. {
  548. case AsyncIteratorState.Allocated:
  549. _enumerator = _source.GetEnumerator();
  550. _state = AsyncIteratorState.Iterating;
  551. goto case AsyncIteratorState.Iterating;
  552. case AsyncIteratorState.Iterating:
  553. if (_enumerator!.MoveNext())
  554. {
  555. _current = await _selector(_enumerator.Current, _cancellationToken).ConfigureAwait(false);
  556. return true;
  557. }
  558. break;
  559. }
  560. await DisposeAsync().ConfigureAwait(false);
  561. return false;
  562. }
  563. }
  564. #endif
  565. }
  566. }