Início / coding / Perguntas / 78375497
Accepted
David Klempfner
Asked: 2024-04-24 08:36:48 +0800 CST

É ruim chamar First() várias vezes em um IEnumerable<T> que na verdade é um List<T>?

  • 772

Encontrei este método:

public async Task SomeMethod(IEnumerable<Member> members)
{
    await DoSomething(members.First());
    await DoSomethingElse(members.First());
}

Está sendo chamado assim:

List<Member> members = GetMembers();
await SomeMethod(members);

Eu sei que isso poderia ser particularmente ruim se GetMembers()retornasse um IQueryable<Member>, mas como é apenas um List<Member>, ainda é ruim ligar First()duas vezes assim? É uma prática recomendada chamar First()uma vez e armazenar o resultado em uma variável?

c#

2 respostas

  1. Best Answer

    Firstfuncionar emSystem.Linq.Enumerable

    Veja System.Linq.Enumerablecomo Firsta função foi implementada:

    public static TSource First<TSource>(this IEnumerable<TSource> source)
{
    TSource? first = source.TryGetFirst(out bool found);
    if (!found)
    {
        ThrowHelper.ThrowNoElementsException();
    }

    return first!;
}

    TryGetFirstfoi chamado, vamos dar uma olhada:

    private static TSource? TryGetFirst<TSource>(this IEnumerable<TSource> source, out bool found)
{
    if (source is null)
    {
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
    }

    return
#if !OPTIMIZE_FOR_SIZE
        source is Iterator<TSource> iterator ? iterator.TryGetFirst(out found) :
#endif
        TryGetFirstNonIterator(source, out found);
}

    Aí TryGetFirstNonIteratorfoi chamado, vamos dar uma olhada:

    private static TSource? TryGetFirstNonIterator<TSource>(IEnumerable<TSource> source, out bool found)
{
    if (source is IList<TSource> list)
    {
        if (list.Count > 0)
        {
            found = true;
            return list[0];
        }
    }
    else
    {
        using (IEnumerator<TSource> e = source.GetEnumerator())
        {
            if (e.MoveNext())
            {
                found = true;
                return e.Current;
            }
        }
    }

    found = false;
    return default;
}

    Como podemos ver, ele retorna list[0] se a origem for IList<TSource>. Código fonte

    Sugestão paraSomeMethod

    Independentemente de como Firstfoi implementado. A pergunta que você fez:

    Eu sei que isso poderia ser particularmente ruim se GetMembers() retornasse um IQueryable, mas como é apenas uma lista, ainda é ruim chamar First() duas vezes assim? É uma prática recomendada chamar First() uma vez e armazenar o resultado em uma variável?

    Acho que sobrecarregar é tudo que você precisa.

    public async Task SomeMethod(Member member)
{
    await DoSomething(member);
    await DoSomethingElse(member);
}
public async Task SomeMethod(IEnumerable<Member> members)
{
    await SomeMethod(members.First());
}
    • 5

  2. É uma prática recomendada chamar First() uma vez e armazenar o resultado em uma variável?

    Sim, porque você não sabe como o método será utilizado. Mesmo que seja usado apenas com uma lista hoje , alguém poderá fazer outra coisa amanhã. Como chamá-lo com algo assim:

    public IEnumerable<Member> GetMembers(){
    var someValue = VeryExpensiveFunction();
    yield return new Member(someValue);
}

    Nesse caso, todas as chamadas .First()precisariam ser executadas VeryExpensiveFunction().

    Armazenar o resultado em uma variável é uma boa solução, ou você pode declarar o método como SomeMethod(List<Member> members), ou SomeMethod(IReadOnlyList<Member> members), caso realmente precise iterá-lo várias vezes.

    • 0

relate perguntas