Существует ли определенное соглашение об именах для методов, возвращающих IAsyncEnumerable?

После C # 5 введены asyncиawait модель для асинхронного программирования, сообщество C # пришло к соглашению об именах, чтобы добавить суффикс "Async" к методам, возвращающим ожидаемый тип, например так:

interface Foo
{
   Task BarAsync();
}

С тех пор было написано, что многие статические анализаторы кода (как на основе Roslyn, так и на основе Roslyn) зависят от этого соглашения об именах при обнаружении запаха кода вокруг асинхронного программирования.

Теперь, когда в C # 8 введена концепция асинхронных перечислимых элементов, которые сами по себе не являются ожидаемыми, но могут использоваться вместе с ними await foreach, кажется, есть два варианта возврата методов именования IAsyncEnumerable:

interface Foo
{
    // No "Async" suffix, indicating that the return value is not awaitable.
    IAsyncEnumerable<T> Bar<T>();
}

или

interface Foo
{
    // With "Async" suffix, indicating that the overall logic is asynchronous.
    IAsyncEnumerable<T> BarAsync<T>();
}

Существовало ли определенное руководство по соглашению об именах (от группы по языку C #, .NET Foundation или других авторитетов) в отношении описанных выше вариантов, например, как соглашение по именованию C # 5 было однозначно стандартизировано и не оставлено на усмотрение программистов?

Нет лучшего руководства, чем то, что уже делают команды .NET :

• ChannelReader.ReadAllAsync возвращаетIAsyncEnumerable<T>
• В EF Core 3 результаты возвращаются в виде IAsyncEnumerableвызова AsAsyncEnumerable ()
• В System.Linq.Async ToAsyncEnumerable () преобразует IEnumerables, Tasks и Observables в IAsyncEnumerables
• Все остальные операторы System.Linq.Asyncсохраняют свои имена. Там нет SelectAsyncили SelectAsAsyncEnumerableпросто Select.

Во всех случаях ясно, каков результат метода. Во всех случаях результаты метода следует ожидать сawait foreach прежде чем их можно будет использовать.

Таким образом, реальная рекомендация остается прежней - убедитесь, что имя проясняет поведение :

• Когда имя уже ясно, например, с помощью AsAsyncEnumerable()илиToAsyncEnumerable() , нет необходимости добавлять суффикс.
• В других случаях добавьте Asyncсуффикс, чтобы разработчики знали, что им нужен await foreachрезультат.

Анализаторы и генераторы кода на самом деле не заботятся об именах методов, они обнаруживают запахи, проверяя сам код. Анализатор кода покажет вам , что вы забыли не ждать Задачу или независимо от того , как вы называете методы и переменные. Генератор может просто использовать отражение, чтобы проверить и испуститьawait foreachIAsyncEnumerableIAsyncEnumerableawait foreach

Это анализаторы стиля, которые проверяют имена. Их работа заключается в обеспечении того, чтобы код использовал согласованный стиль, чтобы разработчики могли понимать код. Анализатор стиля скажет вам, что метод не соответствует выбранному вами стилю. Этот стиль может быть командным или общепринятым руководством по стилю.

И, конечно же, все знают, что общий префикс для полей частного экземпляра есть _:)

Это не асинхронный метод, поэтому имя не должно заканчиваться на «асинхронный». Этот суффикс метода является соглашением, позволяющим сделать очевидным, что метод следует ожидать или результат обрабатывается как задача.

Я думаю, что нормальное возвращающее коллекцию имя уместно. GetFoos () или аналогичный.

Асинхронный суффикс и даже ключевое слово async- это просто шаблон, он не имеет смысла, кроме некоторых аргументов обратной совместимости. C # имеет всю информацию, чтобы различать эти функции так же, как он различает yieldметоды, которые возвращают IEnumerable, поскольку вы знаете, что вам не нужно добавлять что-то вродеenumerable или какое-либо другое ключевое слово в такие методы.

Вам нужно добавить суффикс Async только потому, что C # будет жаловаться на перегрузки, поэтому, по сути, эти два идентичных и они делают одно и то же по всем правилам полиморфизма (если мы не принимаем во внимание человеческий фактор намеренно искажающего поведения):

public interface IMyContract
{
    Task<int> Add(int a, int b);
    int Add(int a, int b);
}

Но вы не можете написать это так, потому что компилятор будет жаловаться. Но эй! Это поглотит это чудовище:

public interface IMyContract : IEnumerable<int>, IEnumerable<long>
{
}

и даже это:

public interface IMyContractAsync
{
    Task<int> Add(int a, int b);
}

public interface IMyContract : IMyContractAsync
{
    int Add(int a, int b);
}

Вот и все. Вы добавляете Async, чтобы компилятор не жаловался. Не уточнять вещи. Чтобы не сделать их лучше. Если нет жалоб - нет причин добавлять их, поэтому в вашем случае я этого избегу, если только это не станет Task<IAsyncEnumerable>.

PS: Просто для лучшего понимания всей картины здесь - если когда-нибудь в будущем кто-то добавит в C # расширения квантово-компьютерного метода (fantazy, да), которые будут работать в другой парадигме, нам, вероятно, понадобится другой суффикс, такой как Quant или что-то еще, потому что C # будет жаловаться иначе. Это будет точно такой же метод, но он будет работать по-другому. Так же, как и полиморфизм. Так же, как и интерфейсы.