C#

internal interface IEnumerable {
  System.Collections.IEnumerator GetEnumerator();
}

Count() is not a method of IEnumerable. A state machine can learn; you could probably get a good estimate the 2nd time around; all other things being equal.

If the IEnumerable returns an object, you could even have it return a status report every so often; you're not limited to returning a particular type.

public class Id : IEnumerable {
    private readonly int Value;
    public Id(int value) => (Value) = (value);
    public IEnumerator GetEnumerator() {
      yield return Value;
    }
}

...they've had no problems mastering 'Select and 'Where, 'Aggregate, etc.
What's so useful about deferred evaluation ?
why do I have to trigger iteration with 'Count() to see how many items it has...

Whilst its possible to create your own custom interfaces and types to tie in with Linq

Gerry Schmitz wrote:

It's an interface to a forward reading state machine who's final implementation is left up to the author. The whole "internal list" concept is an illusion.

endo funk wrote:

Tsk tsk... that type reaction is IMO simply a reflection on an inability to grok

endo funk wrote:

Nope. I quoted his words (question), and responded to that... a fact you apparently missed.

endo funk wrote:

Yes; first off IEnumerable was Microsoft implementation of functional programming algebras for a List. It is essentially a monadic data type that encapsulates List; monadic data types are typically designed to conform to a fairly standard set of functional algebras i.e. providing a common API for computations.

endo funk wrote:

Extension methods... apparently so obvious that you missed it.

Quote:

Imagine you have bright young student sitting down with you, whom you've introduced to Linq, and generics ... and, they've had no problems mastering 'Select and 'Where, 'Aggregate, etc.

You have introduced them to the use of 'yield return' in a method to return an IEnumerable they can turn into an instance of a collection. They "get that," and get use of yield means they can skip direct assignment to a pre-defined, initialized collection, or, a collection instance reference passed in as an 'out parameter.

And you are trying to explain to them the "deferred iteration/evaluation" aspect of IEnumerable, and the way that enables some advanced practices (function chaining).

matBaseBindingSource.Filter = "USnumber = '" + cmbBaseM.SelectedItem + "'";

matBaseBindingSource.Filter = $"USnumber = '{cmbBaseM.SelectedItem}'";

private void ComboBox_SelectedIndexChanged(object sender, EventArgs e)
{
    string[] comboSelections =
    {
        CmbBaseM.SelectedIndex != -1
			? $"BaseM = '{CmbBaseM.GetItemText(CmbBaseM.SelectedItem)}'"
			: string.Empty,
        CmbUmat.SelectedIndex != -1
			? $"Umat = '{CmbUmat.GetItemText(CmbUmat.SelectedItem)}'"
			: string.Empty,
        CmbGmat.SelectedIndex != -1
			? $"Gmat = '{CmbGmat.GetItemText(CmbGmat.SelectedItem)}'"
			: string.Empty
    };
    string filter = string.Join(" AND ", comboSelections.Where(s => !string.IsNullOrEmpty(s)));
    MyBindingSource.Filter = filter;
}

CmbUmat