610public CommandArgument Current

26public T[] Current { get; private set; }

610public CommandArgument Current

610public CommandArgument Current

610public CommandArgument Current

610public CommandArgument Current

936public XmlSchema Current

1472public KeyValue<object, object> Current 1507public KeyValue<K, V> Current

183public T Current

361public T Current

610public CommandArgument Current

610public CommandArgument Current

347public V Current => _valueSet[_index];

34public T Current

69public V Current

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

703K IEnumerator<K>.Current => _e.Current; 820V IEnumerator<V>.Current => _e.Current; 926KeyValuePair<K, V> IEnumerator<KeyValuePair<K, V>>.Current => _e.Current;

32public readonly T Current => default(TIntervalTreeWitness).GetValue(tree, _nodeEnumerator.Current);

51public readonly TNode Current => _currentNode!;

17public readonly VirtualChar Current => virtualCharSequence[_position];

38public T Current => _current.Current;

610public CommandArgument Current

101public TValue Current => _enumerator is not null

52public ParameterProxy Current => new ParameterProxy(_method, (ParameterIndex)_current);

101public TValue Current => _enumerator is not null

52public ParameterProxy Current => new ParameterProxy(_method, (ParameterIndex)_current);

43public KeyValuePair<string, string> Current { get; private set; }

347public V Current => _valueSet[_index];

34public T Current

69public V Current

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

703K IEnumerator<K>.Current => _e.Current; 820V IEnumerator<V>.Current => _e.Current; 926KeyValuePair<K, V> IEnumerator<KeyValuePair<K, V>>.Current => _e.Current;

32public readonly T Current => default(TIntervalTreeWitness).GetValue(tree, _nodeEnumerator.Current);

51public readonly TNode Current => _currentNode!;

17public readonly VirtualChar Current => virtualCharSequence[_position];

38public T Current => _current.Current;

347public V Current => _valueSet[_index];

34public T Current

69public V Current

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

703K IEnumerator<K>.Current => _e.Current; 820V IEnumerator<V>.Current => _e.Current; 926KeyValuePair<K, V> IEnumerator<KeyValuePair<K, V>>.Current => _e.Current;

32public readonly T Current => default(TIntervalTreeWitness).GetValue(tree, _nodeEnumerator.Current);

51public readonly TNode Current => _currentNode!;

17public readonly VirtualChar Current => virtualCharSequence[_position];

38public T Current => _current.Current;

24public VirtualChar Current => _virtualCharSequence[_position];

808public KeyValuePair<string, object?> Current { get; private set; }

134public StringSegment Current

25public UrlMatchingNode Current { get; private set; }

311public ReadOnlyMemory<char> Current => _enumerator.Current.Value;

55public T Current => throw new InvalidOperationException();

204public KeyValuePair<string, StringValues> Current

425public KeyValuePair<string, StringValues> Current

147public KeyValuePair<object, object?> Current => default;

196public KeyValuePair<string, string> Current

220public KeyValuePair<string, StringValues> Current

114public KeyValuePair<string, StringValues> Current => _notEmpty ? _dictionaryEnumerator.Current : default;

630public KeyValuePair<TKey, TValue> Current { get; private set; }

112public HeaderSegment Current

184public object Current => _current!;

808public KeyValuePair<string, object?> Current { get; private set; }

311public ReadOnlyMemory<char> Current => _enumerator.Current.Value;

1029public KeyValuePair<string, ModelStateEntry> Current => 1152public string Current { get; private set; } 1227public ModelStateEntry Current { get; private set; }

50public KeyValuePair<string, object> Current { get; private set; }

110public ValidationEntry Current => _entry;

71public ValidationEntry Current => _entry;

80public ValidationEntry Current => _entry;

84public ValidationEntry Current => _entry;

35public TWrapped Current

342public KeyValuePair<string, string?> Current => _attributes.Get(_index); 452public string Current => _attributes.Get(_index).Key; 557public string? Current => _attributes.Get(_index).Value;

287public KeyValuePair<string, object?> Current

109public KeyValuePair<string, string[]> Current => _current;

154public KeyValuePair<string, StringValues> Current => _current;

134public StringSegment Current

25public UrlMatchingNode Current { get; private set; }

222public KeyValuePair<string, StringValues> Current => Enumerator.Current; 254public readonly KeyValuePair<string, StringValues> Current => _current;

163public readonly KeyValuePair<string, StringValues> Current => _current;

72public readonly KeyValuePair<string, StringValues> Current => _current;

30public KeyValuePair<string, string> Current { get; private set; }

43public KeyValuePair<string, string> Current { get; private set; }

43public KeyValuePair<string, string> Current { get; private set; }

43public KeyValuePair<string, string> Current { get; private set; }

610public CommandArgument Current

630public KeyValuePair<TKey, TValue> Current { get; private set; }

457public (ReadOnlyMemory<byte>, long) Current

85public HubConnectionContext Current => _enumerator.Current.Value;

457public (ReadOnlyMemory<byte>, long) Current

43public KeyValuePair<TKey, TValue> Current => _enumerator.Current;

23public TKey Current => _enumerator.Current.Key;

23public TValue Current => _enumerator.Current.Value;

23public T Current => _enumerator.Current;

389public T Current => _current;

1181public KeyValuePair<TKey, TValue> Current => _current; 1428public TKey Current => _currentKey!; 1627public TValue Current => _currentValue!;

1208public T Current => _current!;

41public int Current => _current;

347public V Current => _valueSet[_index];

589K IEnumerator<K>.Current => _e.Current; 706V IEnumerator<V>.Current => _e.Current; 812KeyValuePair<K, V> IEnumerator<KeyValuePair<K, V>>.Current => _e.Current;

34public T Current

69public V Current

154public IOperation Current => _enumerator.Current;

134public IOperation Current => _enumerator.Current;

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

116public SyntaxNodeOrToken Current

119public SyntaxNodeOrToken Current

75public TNode Current

76public TNode Current

570public SyntaxNodeOrToken Current => _list[_index];

141public SyntaxToken Current => _enumerator.Current;

153public SyntaxToken Current => _enumerator.Current;

145public SyntaxTrivia Current => _enumerator.Current;

142public SyntaxTrivia Current => _enumerator.Current;

108public TextLine Current

347public V Current => _valueSet[_index];

34public T Current

69public V Current

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

703K IEnumerator<K>.Current => _e.Current; 820V IEnumerator<V>.Current => _e.Current; 926KeyValuePair<K, V> IEnumerator<KeyValuePair<K, V>>.Current => _e.Current;

32public readonly T Current => default(TIntervalTreeWitness).GetValue(tree, _nodeEnumerator.Current);

51public readonly TNode Current => _currentNode!;

17public readonly VirtualChar Current => virtualCharSequence[_position];

38public T Current => _current.Current;

347public V Current => _valueSet[_index];

34public T Current

69public V Current

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

703K IEnumerator<K>.Current => _e.Current; 820V IEnumerator<V>.Current => _e.Current; 926KeyValuePair<K, V> IEnumerator<KeyValuePair<K, V>>.Current => _e.Current;

32public readonly T Current => default(TIntervalTreeWitness).GetValue(tree, _nodeEnumerator.Current);

51public readonly TNode Current => _currentNode!;

17public readonly VirtualChar Current => virtualCharSequence[_position];

38public T Current => _current.Current;

347public V Current => _valueSet[_index];

34public T Current

69public V Current

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

703K IEnumerator<K>.Current => _e.Current; 820V IEnumerator<V>.Current => _e.Current; 926KeyValuePair<K, V> IEnumerator<KeyValuePair<K, V>>.Current => _e.Current;

32public readonly T Current => default(TIntervalTreeWitness).GetValue(tree, _nodeEnumerator.Current);

51public readonly TNode Current => _currentNode!;

17public readonly VirtualChar Current => virtualCharSequence[_position];

38public T Current => _current.Current;

347public V Current => _valueSet[_index];

34public T Current

69public V Current

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

32public readonly T Current => default(TIntervalTreeWitness).GetValue(tree, _nodeEnumerator.Current);

51public readonly TNode Current => _currentNode!;

17public readonly VirtualChar Current => virtualCharSequence[_position];

38public T Current => _current.Current;

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

226public (int depth, int localFuncIndex) Current => _current;

29public string Current

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

73public readonly AspNetCoreVirtualChar Current

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

347public V Current => _valueSet[_index];

34public T Current

69public V Current

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

703K IEnumerator<K>.Current => _e.Current; 820V IEnumerator<V>.Current => _e.Current; 926KeyValuePair<K, V> IEnumerator<KeyValuePair<K, V>>.Current => _e.Current;

32public readonly T Current => default(TIntervalTreeWitness).GetValue(tree, _nodeEnumerator.Current);

51public readonly TNode Current => _currentNode!;

17public readonly VirtualChar Current => virtualCharSequence[_position];

38public T Current => _current.Current;

347public V Current => _valueSet[_index];

34public T Current

69public V Current

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

703K IEnumerator<K>.Current => _e.Current; 820V IEnumerator<V>.Current => _e.Current; 926KeyValuePair<K, V> IEnumerator<KeyValuePair<K, V>>.Current => _e.Current;

32public readonly T Current => default(TIntervalTreeWitness).GetValue(tree, _nodeEnumerator.Current);

51public readonly TNode Current => _currentNode!;

17public readonly VirtualChar Current => virtualCharSequence[_position];

38public T Current => _current.Current;

347public V Current => _valueSet[_index];

34public T Current

69public V Current

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

703K IEnumerator<K>.Current => _e.Current; 820V IEnumerator<V>.Current => _e.Current; 926KeyValuePair<K, V> IEnumerator<KeyValuePair<K, V>>.Current => _e.Current;

32public readonly T Current => default(TIntervalTreeWitness).GetValue(tree, _nodeEnumerator.Current);

51public readonly TNode Current => _currentNode!;

17public readonly VirtualChar Current => virtualCharSequence[_position];

38public T Current => _current.Current;

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

347public V Current => _valueSet[_index];

34public T Current

69public V Current

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

32public readonly T Current => default(TIntervalTreeWitness).GetValue(tree, _nodeEnumerator.Current);

51public readonly TNode Current => _currentNode!;

17public readonly VirtualChar Current => virtualCharSequence[_position];

38public T Current => _current.Current;

34public T Current

69public V Current

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

2601 public T Current =>

55public T Current => throw new InvalidOperationException();

230public KeyValuePair<string, TValue> Current => _dictionaryEnumerator.Current;

55public T Current => throw new InvalidOperationException();

55public T Current => throw new InvalidOperationException();

55public T Current => throw new InvalidOperationException();

55public T Current => throw new InvalidOperationException();

55public T Current => throw new InvalidOperationException();

276public KeyValuePair<string, object?> Current => new KeyValuePair<string, object?>(_enumerator.Current.Key, _enumerator.Current.Value);

102public StringSegment Current { get; private set; }

824public string? Current => _current;

293public KeyValuePair<string, object?> Current =>

55public T Current => throw new InvalidOperationException();

55public T Current => throw new InvalidOperationException();

55public T Current => throw new InvalidOperationException();

55public T Current => throw new InvalidOperationException();

55public T Current => throw new InvalidOperationException();

55public T Current => throw new InvalidOperationException();

183 public LocalValueEntry Current { get; private set; }

42 public T Current

404 public object Current { get; private set; }

543Text.TextInterface.FontFamily IEnumerator<Text.TextInterface.FontFamily>.Current

148public Typeface Current

387public Span<U> Current

1064public T Current

830public TextDecoration Current

513public XmlLanguage Current

829public Timeline Current

340Clock IEnumerator<Clock>.Current

563public KeyValuePair<int, CharacterMetrics> Current

832public BitmapEffect Current

407public FontFamilyMap Current

423public FamilyTypeface Current

857public double Current

874public Drawing Current

839public GeneralTransform Current

874public Geometry Current

942public GradientStop Current

857public int Current

929public PathFigure Current

839public PathSegment Current

859public Point Current

839public TextEffect Current

874public Transform Current

859public Vector Current

118public String Current

837public GeneralTransform3D Current

872public Material Current

872public Model3D Current

858public Point3D Current

872public Transform3D Current

858public Vector3D Current

664public Visual3D Current

335public TItem Current

152public IInputElement Current

119object IEnumerator<object>.Current

234public T Current 633public T Current => _FromIterator.Current;

861public ColumnDefinition Current

856public RowDefinition Current

269public DataGridCellInfo Current

76public TextElementType Current

347public V Current => _valueSet[_index];

34public T Current

69public V Current

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

703K IEnumerator<K>.Current => _e.Current; 820V IEnumerator<V>.Current => _e.Current; 926KeyValuePair<K, V> IEnumerator<KeyValuePair<K, V>>.Current => _e.Current;

32public readonly T Current => default(TIntervalTreeWitness).GetValue(tree, _nodeEnumerator.Current);

51public readonly TNode Current => _currentNode!;

17public readonly VirtualChar Current => virtualCharSequence[_position];

38public T Current => _current.Current;

55public T Current => throw new InvalidOperationException();

610public CommandArgument Current

520public T Current => _current!;

1414public KeyValuePair<TKey, TValue> Current { get; private set; } 1648public TKey Current => _enumerator.Current.Key; 1892public TValue Current => _enumerator.Current.Value;

1045public (TElement Element, TPriority Priority) Current => _current;

428public KeyValuePair<TKey, TValue> Current 646public TKey Current 807public TValue Current

823public KeyValuePair<TKey, TValue> Current => new KeyValuePair<TKey, TValue>(_key!, _value!); 909public TKey Current => _currentKey!; 973public TValue Current => _currentValue!;

1938public T Current

391public T Current => _currentElement!;

876public KeyValuePair<TKey, TValue> Current { get; private set; }

247public TSource Current

371public abstract KeyValuePair<long, TSource> Current { get; } 1428public abstract KeyValuePair<long, TSource> Current { get; }

701public readonly KeyValuePair<TKey, TValue> Current

510public readonly T Current

105public T Current

54public KeyValuePair<TKey, TValue> Current

401public KeyValuePair<TKey, TValue> Current

54public T Current

322public T Current

122public T Current

139public T Current

88public KeyValuePair<TKey, TValue> Current

105public T Current

109public T Current

74public KeyValuePair<int, TValue> Current

2092public K Current

277public KeyValuePair<string, object?> Current => _enumerator.Current;

283public T Current => _currentNode.Value;

325public KeyValuePair<string, object?> Current => _tagList[_index];

146public PackageRelationship Current

41public TSource Current => _current;

35public T Current => _array[_index];

478public T Current => _current;

50public T Current { get { return default!; } }

74object? IEnumerator<object?>.Current

38public abstract TInputOutput Current { get; }

57public TOutput Current

70public TElement Current

596public string Current { get { throw new System.PlatformNotSupportedException(System.SR.PlatformNotSupported_NetHttp); } } 654public System.Collections.Generic.KeyValuePair<string, System.Net.Http.Headers.HeaderStringValues> Current { get { throw new System.PlatformNotSupportedException(System.SR.PlatformNotSupported_NetHttp); } }

18public string Current => (string)_enumerator.Current;

78public readonly ReadOnlyTensorSpan<T> Current => _span[_index];

539readonly T IEnumerator<T>.Current => Current;

423readonly T IEnumerator<T>.Current => Current;

81public readonly TensorSpan<T> Current => _span[_index];

465readonly T IEnumerator<T>.Current => Current;

121public T Current 166public new T Current

311public T Current

38public char Current

1810public KeyValuePair<TKey, TValue> Current => _current; 2050public TKey Current => _currentKey!; 2243public TValue Current => _currentValue!;

1837public T Current => _current;

1229public T Current => _current!;

482public T Current => _currentElement!;

71public TResult Current => _current!;

24public TSource Current => current!;

5857public Range Current => new Range(_startCurrent, _endCurrent);

272T IEnumerator<T>.Current => Current;

478public KeyValuePair<TKey, TValue> Current

1750public GCHandle Current

265T IEnumerator<T>.Current => Current;

31public ReadOnlySpan<char> Current => _current;

23public Rune Current => _current;

23public Rune Current => _current;

1609public KeyValue<object, object?> Current => new KeyValue<object, object?>(_enumerator.Key, _enumerator.Value); 1638public KeyValue<K, V> Current

815public XmlSchema Current

232public T Current

30public BlobBuilder Current => _currentOpt!; 75public Blob Current

69public DocumentHandle Current 168public MethodDebugInformationHandle Current 274public LocalScopeHandle Current 337public LocalScopeHandle Current 482public LocalVariableHandle Current 588public LocalConstantHandle Current 687public ImportScopeHandle Current 794public CustomDebugInformationHandle Current

129public ImportDefinition Current

192public SequencePoint Current

79public GenericParameterHandle Current 187public GenericParameterConstraintHandle Current 293public CustomAttributeHandle Current 414public DeclarativeSecurityAttributeHandle Current 521public MethodDefinitionHandle Current 641public FieldDefinitionHandle Current 761public PropertyDefinitionHandle Current 881public EventDefinitionHandle Current 995public MethodImplementationHandle Current 1096public ParameterHandle Current 1208public InterfaceImplementationHandle Current 1298public TypeDefinitionHandle Current 1388public TypeReferenceHandle Current 1478public ExportedTypeHandle Current 1568public MemberReferenceHandle Current 1707public AssemblyReferenceHandle Current 1812public ManifestResourceHandle Current 1902public AssemblyFileHandle Current

3858public System.Security.Cryptography.X509Certificates.X509Certificate2 Current { get { throw new System.PlatformNotSupportedException(System.SR.SystemSecurityCryptography_PlatformNotSupported); } } 3950public System.Security.Cryptography.X509Certificates.X509ChainElement Current { get { throw new System.PlatformNotSupportedException(System.SR.SystemSecurityCryptography_PlatformNotSupported); } } 4065public System.Security.Cryptography.X509Certificates.X509Extension Current { get { throw new System.PlatformNotSupportedException(System.SR.SystemSecurityCryptography_PlatformNotSupported); } }

33public JsonElement Current

32public JsonProperty Current

207public Capture Current

260public Group Current 273KeyValuePair<string, Group> IEnumerator<KeyValuePair<string, Group>>.Current

225public Match Current

161public readonly ValueMatch Current => _current;

274public readonly Range Current => _currentSplit;

54T IEnumerator<T>.Current => (T)_enumerator.Current;

269public KeyValuePair<string, object> Current

159public KeyValuePair<string, object> Current

105public XamlNode Current

610public CommandArgument Current

610public CommandArgument Current

610public CommandArgument Current

610public CommandArgument Current

610public CommandArgument Current

347public V Current => _valueSet[_index];

34public T Current

69public V Current

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

703K IEnumerator<K>.Current => _e.Current; 820V IEnumerator<V>.Current => _e.Current; 926KeyValuePair<K, V> IEnumerator<KeyValuePair<K, V>>.Current => _e.Current;

32public readonly T Current => default(TIntervalTreeWitness).GetValue(tree, _nodeEnumerator.Current);

51public readonly TNode Current => _currentNode!;

17public readonly VirtualChar Current => virtualCharSequence[_position];

38public T Current => _current.Current;

347public V Current => _valueSet[_index];

34public T Current

69public V Current

45public readonly KeyValuePair<TKey, TValue> Current => _enumerator.Current;

25public readonly TKey Current => _enumerator.Current.Key;

25public readonly TValue Current => _enumerator.Current.Value;

28public readonly T Current => _enumerator.Current;

25public readonly T Current => _enumerator.Current;

385public readonly T Current => _current;

1217public readonly KeyValuePair<TKey, TValue> Current => _current; 1472public readonly TKey Current => _currentKey!; 1679public readonly TValue Current => _currentValue!;

1427public readonly T Current => _current;

1363public readonly T Current => _current!;

24public new T Current => throw new InvalidOperationException();

27public T Current => _loneValue;

703K IEnumerator<K>.Current => _e.Current; 820V IEnumerator<V>.Current => _e.Current; 926KeyValuePair<K, V> IEnumerator<KeyValuePair<K, V>>.Current => _e.Current;

32public readonly T Current => default(TIntervalTreeWitness).GetValue(tree, _nodeEnumerator.Current);

51public readonly TNode Current => _currentNode!;

17public readonly VirtualChar Current => virtualCharSequence[_position];

38public T Current => _current.Current;

610public CommandArgument Current

828 public T Current =>

182arguments.Current.Values.Add(arg); 261arguments.Current.Values.Add(arg); 357arguments.Current.Values.Add(arg); 614return _enumerator.Current;

182arguments.Current.Values.Add(arg); 261arguments.Current.Values.Add(arg); 357arguments.Current.Values.Add(arg); 614return _enumerator.Current;

182arguments.Current.Values.Add(arg); 261arguments.Current.Values.Add(arg); 357arguments.Current.Values.Add(arg); 614return _enumerator.Current;

182arguments.Current.Values.Add(arg); 261arguments.Current.Values.Add(arg); 357arguments.Current.Values.Add(arg); 614return _enumerator.Current;

182arguments.Current.Values.Add(arg); 261arguments.Current.Values.Add(arg); 357arguments.Current.Values.Add(arg); 614return _enumerator.Current;

1511KeyValuePair<K, V> current = _enumerator.Current;

185get { return _inner.Current; } 267counterValue[digits[i].Key] = digits[i].Value.Current; 300counterValue[digits[i].Key] = digits[i].Value.Current;

285get { return _e.Current; }

182arguments.Current.Values.Add(arg); 261arguments.Current.Values.Add(arg); 357arguments.Current.Values.Add(arg); 614return _enumerator.Current;

182arguments.Current.Values.Add(arg); 261arguments.Current.Values.Add(arg); 357arguments.Current.Values.Add(arg); 614return _enumerator.Current;

125public T Current => _kvpEnumerator.Current.Key;

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current);

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

152public T Current => _kvpEnumerator.Current.Key;

532var p1 = xMembersEnumerator.Current; 533var p2 = yMembersEnumerator.Current;

182arguments.Current.Values.Add(arg); 261arguments.Current.Values.Add(arg); 357arguments.Current.Values.Add(arg); 614return _enumerator.Current;

64if (!EncodeHeader(headersEnumerator.Current.Key, headersEnumerator.Current.Value, buffer.Slice(currentLength), out int headerLength))

64if (!EncodeHeader(headersEnumerator.Current.Key, headersEnumerator.Current.Value, buffer.Slice(currentLength), out int headerLength))

64if (!EncodeHeader(headersEnumerator.Current.Key, headersEnumerator.Current.Value, buffer.Slice(currentLength), out int headerLength))

64if (!EncodeHeader(headersEnumerator.Current.Key, headersEnumerator.Current.Value, buffer.Slice(currentLength), out int headerLength))

64if (!EncodeHeader(headersEnumerator.Current.Key, headersEnumerator.Current.Value, buffer.Slice(currentLength), out int headerLength))

64if (!EncodeHeader(headersEnumerator.Current.Key, headersEnumerator.Current.Value, buffer.Slice(currentLength), out int headerLength))

102? _enumerator.Current

102? _enumerator.Current

108? SetCurrent(_genericEnumerator.Current.Key, _genericEnumerator.Current.Value, GetKnownRequestHeaderType(_genericEnumerator.Current.Key))

125public T Current => _kvpEnumerator.Current.Key;

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current);

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

152public T Current => _kvpEnumerator.Current.Key;

148element = state.Enumerator.Current;

532var p1 = xMembersEnumerator.Current; 533var p2 = yMembersEnumerator.Current;

125public T Current => _kvpEnumerator.Current.Key;

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current);

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

152public T Current => _kvpEnumerator.Current.Key;

148element = state.Enumerator.Current;

532var p1 = xMembersEnumerator.Current; 533var p2 = yMembersEnumerator.Current;

230var value1 = enumerator1.Current; 231var value2 = enumerator2.Current;

46return Task.FromResult(_responseEnumerator.Current); 83return Task.FromResult(responseEnumerator.Current);

189var currentValue = _enumerator.Current;

767return getCacheExpirationTokenReturnValuesEnumerator.Current; 776return getAllKeysReturnValuesEnumerator.Current; 787Assert.Equal(createNewKeyCallbacksEnumerator.Current.Item1, activationDate); 788Assert.Equal(createNewKeyCallbacksEnumerator.Current.Item2, expirationDate); 789return createNewKeyCallbacksEnumerator.Current.Item3; 800var current = resolveDefaultKeyPolicyReturnValuesEnumerator.Current;

97var key = ModelNames.CreateIndexModelName(_key, _keyEnumerator.Current);

98if (_model.TryGetValue(_keyMappingEnumerator.Current.Value, out value)) 105_entry = new ValidationEntry(_metadata, _keyMappingEnumerator.Current.Key, value);

430var entry = enumerator.Current;

146entries.Add(enumerator.Current);

191entries.Add(enumerator.Current);

206entries.Add(enumerator.Current);

143entries.Add(enumerator.Current);

39object obj = _inner.Current!;

69innerEnumerator.SetupGet(innerEnum => innerEnum.Current)

185enumerator.Current.State.ToString());

52var value = enumerator.Current;

409AnalyzerDebug.Assert(sourceAttributes.Current.Name == targetAttributes.Current.Name); 410CopyAnnotations(sourceAttributes.Current, targetAttributes.Current);

105_current = Convert(_inner.Current);

150_current = Convert(_inner.Current);

64if (!EncodeHeader(headersEnumerator.Current.Key, headersEnumerator.Current.Value, buffer.Slice(currentLength), out int headerLength))

92? SetCurrent(_genericEnumerator.Current.Key, _genericEnumerator.Current.Value, default)

108? SetCurrent(_genericEnumerator.Current.Key, _genericEnumerator.Current.Value, GetKnownRequestHeaderType(_genericEnumerator.Current.Key))

108? SetCurrent(_genericEnumerator.Current.Key, _genericEnumerator.Current.Value, GetKnownRequestHeaderType(_genericEnumerator.Current.Key))

182arguments.Current.Values.Add(arg); 261arguments.Current.Values.Add(arg); 357arguments.Current.Values.Add(arg); 614return _enumerator.Current;

85public HubConnectionContext Current => _enumerator.Current.Value;

114Add(en.Current); 795Insert(index++, en.Current);

235var current = enumerator.Current;

33array[arrayIndex] = enumerator.Current;

68if (chars0.Current != chars1.Current)

1294resolvedPath = enumerator.Current;

1041if (AddCustomAttributeToTable(parentHandle, attributeEnumerator.Current)) 1060if (AddCustomAttributeToTable(parentHandle, attributeEnumerator.Current))

125public T Current => _kvpEnumerator.Current.Key;

52Debug.Assert(sourceAttributes.Current.Name == targetAttributes.Current.Name); 53CopyAnnotations(sourceAttributes.Current, targetAttributes.Current);

803var pair = enumerator.Current; 824pair = enumerator.Current; 835pair = enumerator.Current;

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current);

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

125public T Current => _kvpEnumerator.Current.Key;

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current); 995array[0] = e.Current; 1009array[i] = e.Current; 1020local[i] = e.Current;

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

152public T Current => _kvpEnumerator.Current.Key;

148element = state.Enumerator.Current;

532var p1 = xMembersEnumerator.Current; 533var p2 = yMembersEnumerator.Current;

125public T Current => _kvpEnumerator.Current.Key;

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current); 995array[0] = e.Current; 1009array[i] = e.Current; 1020local[i] = e.Current;

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

152public T Current => _kvpEnumerator.Current.Key;

148element = state.Enumerator.Current;

532var p1 = xMembersEnumerator.Current; 533var p2 = yMembersEnumerator.Current;

125public T Current => _kvpEnumerator.Current.Key;

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current); 995array[0] = e.Current; 1009array[i] = e.Current; 1020local[i] = e.Current;

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

152public T Current => _kvpEnumerator.Current.Key;

148element = state.Enumerator.Current;

532var p1 = xMembersEnumerator.Current; 533var p2 = yMembersEnumerator.Current;

125public T Current => _kvpEnumerator.Current.Key;

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current); 995array[0] = e.Current; 1009array[i] = e.Current; 1020local[i] = e.Current;

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

148element = state.Enumerator.Current;

532var p1 = xMembersEnumerator.Current; 533var p2 = yMembersEnumerator.Current;

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current); 995array[0] = e.Current; 1009array[i] = e.Current; 1020local[i] = e.Current;

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

283var current = enumerator.Current;

1374var firstNode = enumerator.Current; 1390builder.Add(enumerator.Current); 1423builder.Add(enumerator.Current); 1430builder.Add(enumerator.Current);

168var subseqeuntStatement = enumerator.Current; 193if (state.NodeContainsValuePatternOrReferencesInitializedSymbol(enumerator.Current, cancellationToken))

286if (ReplacementChangesSemantics(originalChildNodeEnum.Current, replacedChildNodeEnum.Current, originalRoot, skipVerificationForCurrentNode: true))

4968enumerator.Current.VerifyNamedArgumentValue(0, "X", TypedConstantKind.Enum, (int)new DayOfWeek()); 4970enumerator.Current.VerifyNamedArgumentValue(0, "X", TypedConstantKind.Primitive, new bool()); 4972enumerator.Current.VerifyNamedArgumentValue(0, "X", TypedConstantKind.Primitive, new sbyte()); 4974enumerator.Current.VerifyNamedArgumentValue(0, "X", TypedConstantKind.Primitive, new byte()); 4976enumerator.Current.VerifyNamedArgumentValue(0, "X", TypedConstantKind.Primitive, new short()); 4978enumerator.Current.VerifyNamedArgumentValue(0, "X", TypedConstantKind.Primitive, new ushort()); 4980enumerator.Current.VerifyNamedArgumentValue(0, "X", TypedConstantKind.Primitive, new int()); 4982enumerator.Current.VerifyNamedArgumentValue(0, "X", TypedConstantKind.Primitive, new uint()); 4984enumerator.Current.VerifyNamedArgumentValue(0, "X", TypedConstantKind.Primitive, new char()); 4986enumerator.Current.VerifyNamedArgumentValue(0, "X", TypedConstantKind.Primitive, new float()); 4988enumerator.Current.VerifyNamedArgumentValue(0, "X", TypedConstantKind.Primitive, new Single()); 4990enumerator.Current.VerifyNamedArgumentValue(0, "X", TypedConstantKind.Primitive, new double());

168var subseqeuntStatement = enumerator.Current; 193if (state.NodeContainsValuePatternOrReferencesInitializedSymbol(enumerator.Current, cancellationToken))

2188return _metadataSequence.Current;

59var actualToken = actualEnumerator.Current;

212var current = _treeEnumerator.Current; 241var current = _treeEnumerator.Current; 276var current = _treeEnumerator.Current; 303var tk = _treeEnumerator.Current.Kind();

408Assert.True(sourceNodeOrTokenEnumerator.Current.IsEquivalentTo(destNodeOrTokenEnumerator.Current)); 422Assert.True(sourceTriviaEnumerator.Current.IsEquivalentTo(destTriviaEnumerator.Current));

286if (ReplacementChangesSemantics(originalChildNodeEnum.Current, replacedChildNodeEnum.Current, originalRoot, skipVerificationForCurrentNode: true))

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current); 995array[0] = e.Current; 1009array[i] = e.Current; 1020local[i] = e.Current;

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

532var p1 = xMembersEnumerator.Current; 533var p2 = yMembersEnumerator.Current;

2204if (oldHasToken != newHasToken || oldHasToken && !AreEquivalent(oldTokensEnum.Current, newTokensEnum.Current)) 2225var oldSpan = oldTokensEnum.Current.Span; 2226var newSpan = newTokensEnum.Current.Span; 2267currentSegment = (oldMappedSpan.Path, oldStartLine, lineDelta, oldTokensEnum.Current, newTokensEnum.Current); 2270lastNewToken = newTokensEnum.Current; 2281if (newTokensEnum.Current.HasLeadingTrivia) 2285rudeEditSpan = TextSpan.FromBounds(newTokensEnum.Current.FullSpan.Start, newTokensEnum.Current.SpanStart); 2291rudeEditSpan = TextSpan.FromBounds(lastNewToken.Span.End, newTokensEnum.Current.SpanStart); 2298rudeEditSpan = newTokensEnum.Current.Span;

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current); 995array[0] = e.Current; 1009array[i] = e.Current; 1020local[i] = e.Current;

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

125public T Current => _kvpEnumerator.Current.Key;

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current); 995array[0] = e.Current; 1009array[i] = e.Current; 1020local[i] = e.Current;

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

152public T Current => _kvpEnumerator.Current.Key;

148element = state.Enumerator.Current;

532var p1 = xMembersEnumerator.Current; 533var p2 = yMembersEnumerator.Current;

125public T Current => _kvpEnumerator.Current.Key;

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current); 995array[0] = e.Current; 1009array[i] = e.Current; 1020local[i] = e.Current;

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

152public T Current => _kvpEnumerator.Current.Key;

148element = state.Enumerator.Current;

532var p1 = xMembersEnumerator.Current; 533var p2 = yMembersEnumerator.Current;

125public T Current => _kvpEnumerator.Current.Key;

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current); 995array[0] = e.Current; 1009array[i] = e.Current; 1020local[i] = e.Current;

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

152public T Current => _kvpEnumerator.Current.Key;

148element = state.Enumerator.Current;

532var p1 = xMembersEnumerator.Current; 533var p2 = yMembersEnumerator.Current;

354var value1 = enumerator1.Current; 355var value2 = enumerator2.Current;

424AppendArgumentString(sb, argumentStrings.Current); 536Diagnostic d = e.Current; 557Diagnostic d = e.Current;

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current); 995array[0] = e.Current; 1009array[i] = e.Current; 1020local[i] = e.Current;

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

247Assert.Equal(i2.Current, i);

168Assert.Equal(default(KeyValuePair<string, int>), manualEnum.Current); 171Assert.Equal(default(KeyValuePair<string, int>), manualEnum.Current);

264Assert.Equal(default(KeyValuePair<int, GenericParameterHelper>), manualEnum.Current); 267Assert.Equal(default(KeyValuePair<int, GenericParameterHelper>), manualEnum.Current);

460Assert.Equal(default, enumerator.Current); 462Assert.Equal(default, enumerator.Current); 467Assert.Equal(default, enumerator.Current); 469Assert.Equal(default, enumerator.Current); 480Assert.Equal(set.First(), enumerator.Current);

150Assert.Equal(default(T), enumerator.Current); 154manualArray[i++] = enumerator.Current; 158Assert.Equal(default(T), enumerator.Current); 160Assert.Equal(default(T), enumerator.Current);

59if (e.Current == null) 61Assert.Null(a.Current); 65Assert.IsType(e.Current.GetType(), a.Current); 66Assert.Equal(e.Current, a.Current);

186Assert.Throws<InvalidOperationException>(() => enumerator.Current); 190_ = enumerator.Current; 208object? currentItem = enumerator.Current; 230object? tempItem = enumerator.Current; 260object? currentItem = enumerator.Current; 264object? tempItem = enumerator.Current; 284Assert.Throws<InvalidOperationException>(() => enumerator.Current); 288_ = enumerator.Current; 588T current = enumerator.Current; 589Assert.Equal(current, enumerator.Current); 590Assert.Equal(current, enumerator.Current); 591Assert.Equal(current, enumerator.Current); 623Assert.Throws<InvalidOperationException>(() => enumerator.Current); 625current = enumerator.Current; 639Assert.Throws<InvalidOperationException>(() => enumerator.Current); 641current = enumerator.Current; 658Assert.Throws<InvalidOperationException>(() => enumerator.Current); 660current = enumerator.Current; 678current = enumerator.Current;

628Assert.Throws<InvalidOperationException>(() => enumerator.Current); // enumerator.Current should fail 632current = enumerator.Current; 644Assert.Throws<InvalidOperationException>(() => enumerator.Current); // enumerator.Current should fail 648current = enumerator.Current;

1033Dim currentToken = enumerator.Current 1034Dim nextToken = enumerator.Current 1038nextToken = enumerator.Current 1129Dim currentToken = enumerator.Current 1130Dim nextToken = enumerator.Current 1134nextToken = enumerator.Current

262var (currentV, d) = varrays.Current; 315var (currentV, d) = varrays.Current;

598Debug.Assert(sourceAttributes.Current.Name == targetAttributes.Current.Name); 599CopyAnnotations(sourceAttributes.Current, targetAttributes.Current);

125public T Current => _kvpEnumerator.Current.Key;

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current);

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

532var p1 = xMembersEnumerator.Current; 533var p2 = yMembersEnumerator.Current;

125public T Current => _kvpEnumerator.Current.Key;

52Debug.Assert(sourceAttributes.Current.Name == targetAttributes.Current.Name); 53CopyAnnotations(sourceAttributes.Current, targetAttributes.Current);

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current);

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

46CSharpArgumentInfo info = arginfosEnum.MoveNext() ? arginfosEnum.Current : null;

189MemberInfo member = memberEn.Current;

101AppendDataFrameColumnFromArrowArray(fieldsEnumerator.Current, structArrayEnumerator.Current, ret, field.Name + "_");

546DataFrameColumn column = columnEnumerator.Current; 547object value = rowEnumerator.Current; 585DataFrameColumn column = columnEnumerator.Current; 596DataFrameColumn column = columnEnumerator.Current;

65long row = enumerator.Current; 80long row = enumerator.Current; 137long row = enumerator.Current; 152long row = enumerator.Current; 232long row = enumerator.Current; 290long row = enumerator.Current;

521var curRow = rows.Current;

305long row = enumerator.Current; 320long row = enumerator.Current; 369long row = enumerator.Current; 384long row = enumerator.Current; 433long row = enumerator.Current; 448long row = enumerator.Current; 497long row = enumerator.Current; 512long row = enumerator.Current; 560long row = enumerator.Current; 608long row = enumerator.Current; 652long row = enumerator.Current; 700long row = enumerator.Current; 792long row = enumerator.Current; 807long row = enumerator.Current; 856long row = enumerator.Current; 871long row = enumerator.Current; 920long row = enumerator.Current; 935long row = enumerator.Current; 984long row = enumerator.Current; 999long row = enumerator.Current; 1047long row = enumerator.Current; 1095long row = enumerator.Current; 1139long row = enumerator.Current; 1187long row = enumerator.Current; 1279long row = enumerator.Current; 1294long row = enumerator.Current; 1343long row = enumerator.Current; 1358long row = enumerator.Current; 1407long row = enumerator.Current; 1422long row = enumerator.Current; 1471long row = enumerator.Current; 1486long row = enumerator.Current; 1534long row = enumerator.Current; 1582long row = enumerator.Current; 1626long row = enumerator.Current; 1674long row = enumerator.Current; 1766long row = enumerator.Current; 1781long row = enumerator.Current; 1830long row = enumerator.Current; 1845long row = enumerator.Current; 1894long row = enumerator.Current; 1909long row = enumerator.Current; 1958long row = enumerator.Current; 1973long row = enumerator.Current; 2021long row = enumerator.Current; 2069long row = enumerator.Current; 2113long row = enumerator.Current; 2161long row = enumerator.Current; 2253long row = enumerator.Current; 2268long row = enumerator.Current; 2317long row = enumerator.Current; 2332long row = enumerator.Current; 2381long row = enumerator.Current; 2396long row = enumerator.Current; 2445long row = enumerator.Current; 2460long row = enumerator.Current; 2508long row = enumerator.Current; 2556long row = enumerator.Current; 2600long row = enumerator.Current; 2648long row = enumerator.Current; 2740long row = enumerator.Current; 2755long row = enumerator.Current; 2804long row = enumerator.Current; 2819long row = enumerator.Current; 2868long row = enumerator.Current; 2883long row = enumerator.Current; 2932long row = enumerator.Current; 2947long row = enumerator.Current; 2995long row = enumerator.Current; 3043long row = enumerator.Current; 3087long row = enumerator.Current; 3135long row = enumerator.Current; 3227long row = enumerator.Current; 3242long row = enumerator.Current; 3291long row = enumerator.Current; 3306long row = enumerator.Current; 3355long row = enumerator.Current; 3370long row = enumerator.Current; 3419long row = enumerator.Current; 3434long row = enumerator.Current; 3482long row = enumerator.Current; 3530long row = enumerator.Current; 3574long row = enumerator.Current; 3622long row = enumerator.Current; 3714long row = enumerator.Current; 3729long row = enumerator.Current; 3778long row = enumerator.Current; 3793long row = enumerator.Current; 3842long row = enumerator.Current; 3857long row = enumerator.Current; 3906long row = enumerator.Current; 3921long row = enumerator.Current; 3969long row = enumerator.Current; 4017long row = enumerator.Current; 4061long row = enumerator.Current; 4109long row = enumerator.Current; 4201long row = enumerator.Current; 4216long row = enumerator.Current; 4265long row = enumerator.Current; 4280long row = enumerator.Current; 4329long row = enumerator.Current; 4344long row = enumerator.Current; 4393long row = enumerator.Current; 4408long row = enumerator.Current; 4456long row = enumerator.Current; 4504long row = enumerator.Current; 4548long row = enumerator.Current; 4596long row = enumerator.Current; 4688long row = enumerator.Current; 4703long row = enumerator.Current; 4752long row = enumerator.Current; 4767long row = enumerator.Current; 4816long row = enumerator.Current; 4831long row = enumerator.Current; 4880long row = enumerator.Current; 4895long row = enumerator.Current; 4943long row = enumerator.Current; 4991long row = enumerator.Current; 5035long row = enumerator.Current; 5083long row = enumerator.Current; 5175long row = enumerator.Current; 5190long row = enumerator.Current; 5239long row = enumerator.Current; 5254long row = enumerator.Current; 5303long row = enumerator.Current; 5318long row = enumerator.Current; 5367long row = enumerator.Current; 5382long row = enumerator.Current; 5430long row = enumerator.Current; 5478long row = enumerator.Current; 5522long row = enumerator.Current; 5570long row = enumerator.Current; 5662long row = enumerator.Current; 5677long row = enumerator.Current; 5726long row = enumerator.Current; 5741long row = enumerator.Current; 5790long row = enumerator.Current; 5805long row = enumerator.Current; 5854long row = enumerator.Current; 5869long row = enumerator.Current; 5917long row = enumerator.Current; 5965long row = enumerator.Current; 6009long row = enumerator.Current; 6057long row = enumerator.Current;

246var value1 = enumerator1.Current; 247var value2 = enumerator2.Current;

2602 GuardNotNull("Tried to get Current on a disposed enumerator", innerEnumerator).Current; 2605 GuardNotNull("Tried to get Current on a disposed enumerator", innerEnumerator).Current;

131string firstTag = iterator.Current; 151oversized[count++] = iterator.Current;

50string currentArg = enumerator.Current; 102value = enumerator.Current;

320RuntimeAssetGroup group = groups.Current;

89KeyValuePair<string, object?> pair = enumerator.Current;

36string line = enumerableLines.Current.Trim().ToString();

150ReadOnlySpan<char> firstLine = enumerableLines.Current.TrimStart().Span; 158UpdateTcpStateInfo(enumerableLines.Current.Span, tcpStateInfo);

42var firstItem = enumerator.Current.AsSpan(); 52currentItem = enumerator.Current.AsSpan(); 76currentItem = enumerator.Current.AsSpan(); 87currentItem = enumerator.Current.AsSpan();

249_stringBuilder.Append(enumerator.Current.Key); 251_stringBuilder.Append(enumerator.Current.Value); 256_stringBuilder.Append(enumerator.Current.Key); 258_stringBuilder.Append(enumerator.Current.Value); 276public KeyValuePair<string, object?> Current => new KeyValuePair<string, object?>(_enumerator.Current.Key, _enumerator.Current.Value);

266_stringBuilder.Append(enumerator.Current.Key); 268_stringBuilder.Append(enumerator.Current.Value); 273_stringBuilder.Append(enumerator.Current.Key); 275_stringBuilder.Append(enumerator.Current.Value); 294new KeyValuePair<string, object?>(_enumerator.Current.Key, _enumerator.Current.Value);

44 get { return _enumerator.Current as T; }

83var config = _configsEnumerator.Current;

34var res = _enumerator.Current;

505var model = enumerator.Current;

1604block = _toDecompressEnumerator.Current; 1640_curr = _toReadEnumerator.Current; 1658_curr = _toReadEnumerator.Current; 1859block = _toDecompressEnumerator.Current; 1923_curr = _toReadEnumerator.Current; 1947_curr = _toReadEnumerator.Current;

293_rows.Index = _ator.Current;

739_currentRow = result ? _enumerator.Current : null;

147posScore = posSorted.Current; 148var negScore = negSorted.Current; 171posScore = posSorted.Current; 179negScore = negSorted.Current; 195if (posScore == negSorted.Current) 252posScore = posSorted.Current.Score; 253var negScore = negSorted.Current.Score; 256var weight = posSorted.Current.Weight; 263var weight = negSorted.Current.Weight; 279var posWeight = posSorted.Current.Weight; 285posScore = posSorted.Current.Score; 289var negWeight = negSorted.Current.Weight; 295negScore = negSorted.Current.Score; 309var weight = posSorted.Current.Weight; 316var weight = negSorted.Current.Weight; 319if (posScore == negSorted.Current.Score)

1968int irow = kvEnums[i].Current.Key; 1969int jrow = kvEnums[j].Current.Key; 1994var kvp = kvEnum.Current; 2124int last = lastOn[hotEnumerator.Current]; 2134lastOn[hotEnumerator.Current] = iFeatureLocal; 2270int i = hotEnumerator.Current; 2318lastOn[hotEnumerator.Current] = iFeature;

221double skippedDocs = g.Current + 1; // Number docs till the next good one.

228if (e1.Current.CompareTo(e2.Current) <= 0) 230yield return e1.Current; 235yield return e2.Current; 241yield return e1.Current; 246yield return e2.Current;

557_curDataSetRow = _dataSetEnumerator.Current; 562_readerOptions.Offset = (long)_blockEnumerator.Current * _readerOptions.Count;

519string curPath = _parent._files.GetPathOrNull(_fileOrder.Current); 522Ch.Warning($"File at index {_fileOrder.Current} is missing a path. Loading of file is being skipped.");

286=> value = _enumerator.Current.Label; 291=> value = _enumerator.Current.Text.AsMemory();

57if (columnsEnumerator.Current.Name != labelName) 58featuresList.Add(columnsEnumerator.Current.Name);

457suffixList.Add(suffix.Current); 458seqList.Add(seq.Current); 465seqList[idx++ % seqList.Count] = seq.Current;

165Assert.True(CompareThroughReflection(enumeratorSimple.Current, originalEnumerator.Current)); 238Assert.True(CompareThroughReflection(enumeratorSimple.Current, originalEnumerator.Current)); 264Assert.True(CompareThroughReflection(enumeratorSimple.Current, originalEnumerator.Current)); 319Assert.True(CompareThroughReflection(enumeratorSimple.Current, originalEnumerator.Current)); 320Assert.True(enumeratorSimple.Current.UnusedPropertyWithPrivateSetter == 100); 348Assert.True(CompareThroughReflection(enumeratorSimple.Current, originalEnumerator.Current)); 400Assert.True(CompareThroughReflection(enumeratorSimple.Current, originalEnumerator.Current)); 450Assert.True(CompareThroughReflection(enumeratorSimple.Current, originalEnumerator.Current)); 488Assert.True(enumeratorSimple.Current.GetDay == originalEnumerator.Current.Day && 489enumeratorSimple.Current.GetHour == originalEnumerator.Current.Hour);

888var row = summaryDataEnumerator.Current; 895var row = summaryDataEnumerator.Current;

133Assert.True(colEnumerator.Current.outputColumnName == "f2" && 134colEnumerator.Current.inputColumnNames[0] == "float1" && 135colEnumerator.Current.inputColumnNames[1] == "float1"); 137Assert.True(colEnumerator.Current.outputColumnName == "f3" && 138colEnumerator.Current.inputColumnNames[0] == "float4" && 139colEnumerator.Current.inputColumnNames[1] == "float1");

139row = enumerator.Current; 197row = enumerator.Current; 404row = enumerator.Current;

67row = enumerator.Current; 111row = enumerator.Current; 162row = enumerator.Current; 220row = enumerator.Current;

167int current = enumerator.Current; 183current = enumerator.Current; 204current = enumerator.Current; 392int current = enumerator.Current; 412current = enumerator.Current; 417if (!EncodeByte(enumerator.Current, OneByteUtf8EncodingMaxId, ByteCodeToIdOffset, ref bytesCount, buffer, ref charsWritten, ref idsConsumed, ref bytesPoolArray)) 468current = enumerator.Current;

144Token tok = _buffer[_itokLim++] = _tokens.Current;

165ReadOnlyMemory<char> token = ator.Current; 190token = ator.Current;

408var column = columns.Current;

564return ((IEnumerator<Text.TextInterface.FontFamily>)this).Current; 658string ordinalName = familyNames.Current;

154Text.TextInterface.Font face = _familyEnumerator.Current; 159FamilyTypeface familyTypeface = _familyTypefaceEnumerator.Current; 179return ((IEnumerator<Typeface>)this).Current;

354return ((IEnumerator<Clock>)this).Current;

387KeyValuePair<XmlLanguage, string> entry = _enumerator.Current;

349TextSegment rangeSegment = rangeEnumerator.MoveNext() ? rangeEnumerator.Current : TextSegment.Null; 377Debug.Assert(rangeEnumerator.Current.IsNull || !next || 378(rangeSegment.End.CompareTo(rangeEnumerator.Current.Start) <= 0), 380rangeSegment = next ? rangeEnumerator.Current : TextSegment.Null; 419rangeSegment = rangeEnumerator.MoveNext() ? rangeEnumerator.Current : TextSegment.Null; 435_segments.Insert(ind++, new HighlightSegment(rangeEnumerator.Current.Start, rangeEnumerator.Current.End, highlightRange));

202ourSegment = ourEnumerator.Current; 203theirSegment = theirEnumerator.Current; 291Invariant.Assert(otherSegment.Equals(TextSegment.Null) || otherSegment.Equals(enumerator.Current) || otherSegment.End.CompareTo(enumerator.Current.Start) <= 0, "TextSegments are overlapping or not ordered."); 294otherSegment = enumerator.Current; 393Invariant.Assert(otherSegment.Equals(TextSegment.Null) || otherSegment.Equals(enumerator.Current) || otherSegment.End.CompareTo(enumerator.Current.Start) <= 0, "TextSegments are overlapping or not ordered."); 396otherSegment = enumerator.Current;

765get { return _ie.Current.Item; }

595Rect elementRect = enumerator.Current;

349return m_enumerator.Current;

895GetPageAsyncRequest asyncRequest = ienum.Current.Value; 900notificationList.Add(ienum.Current.Key);

1219GetPageAsyncRequest asyncRequest = ienum.Current.Value; 1223completedRequests.Add(ienum.Current.Key);

1085nameScope.RegisterNameInternal(nameEnumerator.Current, createdObject);

589Rect rect = enumerator.Current; 606Rect rect = enumerator.Current; 1455IInputElement current = enumerator.Current; 1513IInputElement current = enumerator.Current; 1627IInputElement current = enumerator.Current; 1695IInputElement current = enumerator.Current; 2420Rect rect = enumerator.Current;

62Uri referralUri = licenseEnumerator.Current.ReferralInfoUri;

839IInputElement element = enumerator.Current;

125public T Current => _kvpEnumerator.Current.Key;

607var previous = e.Current; 610if (comparer.Compare(previous, e.Current) > 0) 615previous = e.Current; 682line[i] = e.Current; 733TSource result = e.Current; 898if (!enumerator2.MoveNext() || !comparer(enumerator.Current, enumerator2.Current)) 926var result = e.Current; 929result = func(result, e.Current); 995array[0] = e.Current; 1009array[i] = e.Current; 1020local[i] = e.Current;

118Add(en.Current); 338Add(en.Current); 950Insert(index++, en.Current);

152public T Current => _kvpEnumerator.Current.Key;

148element = state.Enumerator.Current;

532var p1 = xMembersEnumerator.Current; 533var p2 = yMembersEnumerator.Current;

286if (ReplacementChangesSemantics(originalChildNodeEnum.Current, replacedChildNodeEnum.Current, originalRoot, skipVerificationForCurrentNode: true))

182arguments.Current.Values.Add(arg); 261arguments.Current.Values.Add(arg); 357arguments.Current.Values.Add(arg); 614return _enumerator.Current;

60arr[0] = en.Current; 82arr[count++] = en.Current;

2301public DictionaryEntry Entry => new DictionaryEntry(_enumerator.Current.Key, _enumerator.Current.Value); 2303public object Key => _enumerator.Current.Key; 2305public object? Value => _enumerator.Current.Value;

251return _source.Current.Value;

710_sharedReader.Current); 795_sharedReader.Current); 821_sharedReader.Current);

700/// <inheritdoc cref="IEnumerator{T}.Current" />

509/// <inheritdoc cref="IEnumerator{T}.Current" />

21get { return new DictionaryEntry(_inner.Current.Key, _inner.Current.Value); } 26get { return _inner.Current.Key; } 31get { return _inner.Current.Value; }

58get { return _enumeratorObject != null ? _enumeratorObject.Current : _enumeratorStruct.Current; }

55ImmutableStack<T> forwards = ImmutableStack.Create(e.Current); 60backwards = backwards.Push(e.Current);

253values[i] = this[keylist.Current]; 254Debug.Assert(null != values[i], $"null value {keylist.Current}");

111current = rows.Current; 138current = rows.Current;

89KeyValuePair<string, object?> pair = enumerator.Current;

1643_last = _first = new DiagNode<KeyValuePair<string, object?>>(e.Current); 1647_last.Next = new DiagNode<KeyValuePair<string, object?>>(e.Current); 1667_last = _first = new DiagNode<KeyValuePair<string, object?>>(e.Current); 1671_last!.Next = new DiagNode<KeyValuePair<string, object?>>(e.Current); 1677_last.Next = new DiagNode<KeyValuePair<string, object?>>(e.Current);

30_last = _first = new DiagNode<T>(e.Current); 34_last.Next = new DiagNode<T>(e.Current);

135KeyValuePair<string, string?> item = e.Current;

214KeyValuePair<string, string?> item = e.Current;

119KeyValuePair<string, string> kvp = enumerator.Current;

125return _enumerator.Current; 150return _enumerator.Current; 170PackageRelationship r = _enumerator.Current;

45result = e.Current; 48result = func(result, e.Current);

123TSource value = enumerator.Current; 155TSource value = enumerator.Current;

65_current = _enumerator.Current;

62long sum = e.Current; 67checked { sum += e.Current; } 110TAccumulator sum = TAccumulator.CreateChecked(e.Current); 114checked { sum += TAccumulator.CreateChecked(e.Current); } 145TSource? value = e.Current; 153value = e.Current; 200TAccumulator sum = TAccumulator.CreateChecked(selector(e.Current)); 205checked { sum += TAccumulator.CreateChecked(selector(e.Current)); } 241TSelector? value = selector(e.Current); 249value = selector(e.Current);

89array[0] = e.Current; 103array[i] = e.Current; 114local[i] = e.Current;

98/// than each <see cref="System.Collections.IEnumerator.MoveNext"/> and <see cref="IEnumerator{T}.Current"/> calls having to traverse all of the previous 246_current = _enumerator.Current;

117return e.Current; 302return e.Current;

60TSource value = enumerator.Current;

52_current = _enumerator.Current; 66_current = _enumerator.Current;

104if (EqualityComparer<TSource>.Default.Equals(enumerator.Current, value))

81TSource element = enumerator.Current; 123TSource element = _enumerator.Current; 134element = _enumerator.Current;

140return e.Current; 161queue.Enqueue(e.Current); 169queue.Enqueue(e.Current);

93return e.Current;

56TOuter item = e.Current;

260TOuter item = e.Current;

95result = e.Current; 142TSource result = e.Current; 147TSource element = e.Current;

256TOuter item = e.Current;

44value = e.Current; 59T? cur = e.Current; 72T? cur = e.Current; 141value = e.Current; 149value = e.Current; 154T x = e.Current; 180value = e.Current; 192T? cur = e.Current; 201T? cur = e.Current; 250value = e.Current; 253decimal x = e.Current; 280value = e.Current; 287decimal? cur = e.Current; 348value = e.Current; 354TSource next = e.Current; 368value = e.Current; 373TSource next = e.Current; 384TSource next = e.Current; 449TSource value = e.Current; 466value = e.Current; 474TSource nextValue = e.Current; 489TSource nextValue = e.Current; 502TSource nextValue = e.Current; 543value = selector(e.Current); 546TResult x = selector(e.Current); 577value = selector(e.Current); 592TResult? cur = selector(e.Current); 605TResult? cur = selector(e.Current); 648value = selector(e.Current); 656value = selector(e.Current); 661TResult x = selector(e.Current); 692value = selector(e.Current); 704TResult? cur = selector(e.Current); 713TResult? cur = selector(e.Current); 747value = selector(e.Current); 750decimal x = selector(e.Current); 781value = selector(e.Current); 788decimal? cur = selector(e.Current); 823value = selector(e.Current); 830TResult x = selector(e.Current); 844value = selector(e.Current); 847TResult x = selector(e.Current);

132value = e.Current; 135T x = e.Current;

46value = e.Current; 55T? cur = e.Current; 117value = e.Current; 125T x = e.Current; 165value = e.Current; 177T? cur = e.Current; 230value = e.Current; 233decimal x = e.Current; 259value = e.Current; 266decimal? cur = e.Current; 327value = e.Current; 333TSource next = e.Current; 347value = e.Current; 352TSource next = e.Current; 363TSource next = e.Current; 428TSource value = e.Current; 445value = e.Current; 453TSource nextValue = e.Current; 468TSource nextValue = e.Current; 481TSource nextValue = e.Current; 522value = selector(e.Current); 525TResult x = selector(e.Current); 558value = selector(e.Current); 567TResult? cur = selector(e.Current); 609value = selector(e.Current); 617TResult x = selector(e.Current); 661value = selector(e.Current); 673TResult? cur = selector(e.Current); 711value = selector(e.Current); 714decimal x = selector(e.Current); 745value = selector(e.Current); 752decimal? cur = selector(e.Current); 787value = selector(e.Current); 794TResult x = selector(e.Current); 808value = selector(e.Current); 811TResult x = selector(e.Current);

45value = e.Current; 52TElement x = e.Current;

175TElement value = e.Current; 179TElement x = e.Current; 200TElement value = e.Current; 204TElement current = e.Current; 273TElement resultValue = e.Current; 280TElement nextValue = e.Current; 293TElement nextValue = e.Current; 325TElement resultValue = e.Current; 332TElement nextValue = e.Current; 345TElement nextValue = e.Current; 406TElement resultValue = e.Current; 412TElement nextValue = e.Current; 423TElement nextValue = e.Current;

79result = e.Current; 112return e.Current;

254TInner item = e.Current;

145_current = _selector(_enumerator.Current); 289_current = _selector(_enumerator.Current);

87return _selector(e.Current); 109return _selector(e.Current); 123TSource last = e.Current; 127last = e.Current;

201TSource element = _sourceEnumerator.Current; 218_current = _subEnumerator.Current;

60if (!(e2.MoveNext() && comparer.Equals(e1.Current, e2.Current)))

239reservoir = new List<TSource>(Math.Min(takeCount, 4)) { e.Current }; 248reservoir.Add(e.Current); 260reservoir[(int)r] = e.Current;

93TSource result = e.Current; 144TSource result = e.Current; 149if (predicate(e.Current))

66TSource element = e.Current; 72yield return e.Current; 111TSource element = e.Current; 117yield return e.Current;

16while (e.MoveNext()) yield return e.Current;

329_current = _enumerator.Current; 410return en.Current; 432return en.Current; 465result = en.Current; 492builder.Add(en.Current); 520builder.Add(en.Current);

122queue.Enqueue(e.Current); 129queue.Enqueue(e.Current); 137queue.Enqueue(e.Current); 178queue.Enqueue(e.Current); 186queue.Enqueue(e.Current);

42yield return e.Current;

140TSource element = _enumerator.Current; 155TSource element = _enumerator.Current;

127TSource item = _enumerator.Current; 401TSource item = _enumerator.Current;

103TSource current = e.Current; 111current = e.Current; 661TSource current = e.Current; 669current = e.Current;

81yield return (e1.Current, e2.Current); 91yield return resultSelector(e1.Current, e2.Current); 102yield return (e1.Current, e2.Current, e3.Current);

221if (en.Current == _arg0) 224return en.Current == _arg1; 274if (en.Current == _arg0) 277if (en.Current == _arg1) 280return en.Current == _arg2; 341if (en.Current == _arg0) 344if (en.Current == _arg1) 347if (en.Current == _arg2) 350return en.Current == _arg3; 425if (en.Current == _arg0) 428if (en.Current == _arg1) 431if (en.Current == _arg2) 434if (en.Current == _arg3) 437return en.Current == _arg4; 565return ExpressionUtils.ReturnObject<Expression>(_body) == en.Current;

560return en.Current == ExpressionUtils.ReturnObject<Expression>(_arg0); 625if (en.Current == _arg0) 628return en.Current == _arg1; 696if (en.Current == _arg0) 699if (en.Current == _arg1) 702return en.Current == _arg2; 773if (en.Current == _arg0) 776if (en.Current == _arg1) 779if (en.Current == _arg2) 782return en.Current == _arg3;

127while (hasCookie && cookieEnumerator.Current.Key == i) 129cookie = cookieEnumerator.Current.Value;

410return en.Current == ExpressionUtils.ReturnObject<ParameterExpression>(_par0); 467if (en.Current == _par0) 470return en.Current == _par1; 532if (en.Current == _par0) 535if (en.Current == _par1) 538return en.Current == _par2;

291return en.Current == ExpressionUtils.ReturnObject<Expression>(_arg0); 348if (en.Current == _arg0) 351return en.Current == _arg1; 415if (en.Current == _arg0) 418if (en.Current == _arg1) 421return en.Current == _arg2; 488if (en.Current == _arg0) 491if (en.Current == _arg1) 494if (en.Current == _arg2) 497return en.Current == _arg3; 567if (en.Current == _arg0) 570if (en.Current == _arg1) 573if (en.Current == _arg2) 576if (en.Current == _arg3) 579return en.Current == _arg4; 668return en.Current == ExpressionUtils.ReturnObject<Expression>(_arg0); 729if (en.Current == _arg0) 732return en.Current == _arg1; 796if (en.Current == _arg0) 799if (en.Current == _arg1) 802return en.Current == _arg2;

68Add(en.Current);

168output.Add(enumerator.Current);

48get { return ((IEnumerator<TInputOutput>)this).Current; }

656chunkBuffer[i] = _source.Current;

127accumulator = _finalReduce(accumulator, enumerator.Current); 138accumulator = enumerator.Current;

315Pair<TInputOutput, TLeftKey> currentPair = _outputEnumerator.Current.Value;

386Pair<TInputOutput, ConcatKey<TLeftKey, TRightKey>> current = _outputEnumerator.Current.Value;

127yield return _resultSelector(leftEnumerator.Current, rightEnumerator.Current);

53count += enumerator.Current;

52Pair<decimal, long> result = enumerator.Current; 59result.First += enumerator.Current.First; 60result.Second += enumerator.Current.Second;

56decimal best = enumerator.Current; 63decimal current = enumerator.Current; 74decimal current = enumerator.Current;

49sum += enumerator.Current;

52Pair<double, long> result = enumerator.Current; 59result.First += enumerator.Current.First; 60result.Second += enumerator.Current.Second;

62double best = enumerator.Current; 69double current = enumerator.Current; 80double current = enumerator.Current;

49sum += enumerator.Current;

52Pair<double, long> result = enumerator.Current; 59result.First += enumerator.Current.First; 60result.Second += enumerator.Current.Second;

61float best = enumerator.Current; 68float current = enumerator.Current; 79float current = enumerator.Current;

49sum += enumerator.Current;

52Pair<long, long> result = enumerator.Current; 59result.First += enumerator.Current.First; 60result.Second += enumerator.Current.Second;

56int best = enumerator.Current; 63int current = enumerator.Current; 74int current = enumerator.Current;

52sum += enumerator.Current;

52Pair<long, long> result = enumerator.Current; 59result.First += enumerator.Current.First; 60result.Second += enumerator.Current.Second;

52count += enumerator.Current;

56long best = enumerator.Current; 63long current = enumerator.Current; 74long current = enumerator.Current;

51sum += enumerator.Current;

51Pair<decimal, long> result = enumerator.Current; 58result.First += enumerator.Current.First; 59result.Second += enumerator.Current.Second;

55decimal? best = enumerator.Current; 62decimal? current = enumerator.Current; 73decimal? current = enumerator.Current;

49sum += enumerator.Current.GetValueOrDefault();

51Pair<double, long> result = enumerator.Current; 58result.First += enumerator.Current.First; 59result.Second += enumerator.Current.Second;

61double? best = enumerator.Current; 68double? current = enumerator.Current; 80double? current = enumerator.Current;

49sum += enumerator.Current.GetValueOrDefault();

51Pair<double, long> result = enumerator.Current; 58result.First += enumerator.Current.First; 59result.Second += enumerator.Current.Second;

61float? best = enumerator.Current; 68float? current = enumerator.Current; 80float? current = enumerator.Current;

49sum += enumerator.Current.GetValueOrDefault();

51Pair<long, long> result = enumerator.Current; 58result.First += enumerator.Current.First; 59result.Second += enumerator.Current.Second;

55int? best = enumerator.Current; 62int? current = enumerator.Current; 73int? current = enumerator.Current;

51sum += enumerator.Current.GetValueOrDefault();

51Pair<long, long> result = enumerator.Current; 58result.First += enumerator.Current.First; 59result.Second += enumerator.Current.Second;

55long? best = enumerator.Current; 62long? current = enumerator.Current; 73long? current = enumerator.Current;

51sum += enumerator.Current.GetValueOrDefault();

58yield return enumerator.Current; 220KeyValuePair<long, TElement> current = _sourceEnumerator.Current; 255currentElement = _sourceEnumerator.Current;

66return _openedQueryEnumerator.Current; 85get { return ((IEnumerator<TOutput>)this).Current; }

79if (enumerator.Current == _qualification)

62if (enumerator.Current)

261KeyValuePair<Wrapper<TInputOutput>, TKey> currentPair = _hashLookupEnumerator.Current;

151TSource current = e.Current;

327currentElement = _selectManyOperator._resultSelector(_mutables._currentLeftElement, _currentRightSource.Current); 334currentElement = _currentRightSourceAsOutput.Current; 456currentElement = _selectManyOperator._resultSelector(_mutables._currentLeftElement, _currentRightSource.Current); 463currentElement = _currentRightSourceAsOutput.Current;

41elem = enumerator.Current;

1566acc = (TAccumulate)(object)enumerator.Current!; 1571TSource elem = enumerator.Current; 4398if (!(e2.MoveNext() && comparer.Equals(e1.Current, e2.Current))) return false; 4893list.Add(input.Current); 4975TSource val = input.Current; 5072TSource src = input.Current; 5159lookup.Add(input.Current); 5246lookup.Add(input.Current); 5340TSource current = e.Current;

305MethodInfo mi = en.Current;

380/// <inheritdoc cref="IEnumerator{T}.Current" />

60arr[0] = en.Current; 82arr[count++] = en.Current;

238arr[i++] = e.Current; 466array[i++] = e.Current;

87Add(en.Current); 271Add(en.Current); 857Insert(index++, en.Current);

227get => new DictionaryEntry(_enumerator.Current.Key, _enumerator.Current.Value); 230public object Key => _enumerator.Current.Key; 232public object? Value => _enumerator.Current.Value;

160string? firstValue = en.Current; 173result.Append(en.Current); 809string? firstValue = en.Current; 825result.Append(en.Current); 952char c = en.Current; // save the first value 970c = en.Current; 984T value = e.Current; // save the first value 1000result.AppendFormatted(e.Current); 1010string? firstString = e.Current?.ToString(); // save the first value 1026result.Append(e.Current?.ToString());

1248T value = en.Current; 1257value = en.Current;

6975Task task = e.Current;

1642KeyValuePair<K, V> current = _enumerator.Current;

47string memberName = _memberNamesIterator.Current;

87newSequence.Add(sequence.Current); 97newSequence.Add(_sequencesToMerge[0].Current); 122int cmp = _runtime.ComparePosition(sequence.Current, _sequencesToMerge[i].Current);