主页 / coding / 问题 / 78375497
Accepted
David Klempfner
Asked: 2024-04-24 08:36:48 +0800 CST

在实际上是 List<T> 的 IEnumerable<T> 上多次调用 First() 是否不好？

  • 772

我找到了这个方法：

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

它被这样称呼：

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

GetMembers()我知道如果返回一个，这可能会特别糟糕IQueryable<Member>，但由于它只是一个，这样List<Member>调用两次仍然不好吗？First()最好的做法是调用First()一次并将结果存储在变量中吗？

c#

2 个回答

  1. Best Answer

    First函数于System.Linq.Enumerable

    以下是功能的实现System.Linq.Enumerable方式：First

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

    return first!;
}

    TryGetFirst被叫了，我们来看一下：

    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);
}

    然后就TryGetFirstNonIterator被调用了，我们来看一下：

    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;
}

    正如我们所看到的，如果源是 ，它确实返回 list[0] IList<TSource>。 源代码

    建议SomeMethod

    不管如何First实施。你问的问题：

    我知道如果 GetMembers() 返回一个 IQueryable，这可能会特别糟糕，但由于它只是一个列表，所以像这样调用 First() 两次仍然不好吗？最好的做法是调用 First() 一次并将结果存储在变量中吗？

    我认为超载就是你所需要的。

    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. 最好的做法是调用 First() 一次并将结果存储在变量中吗？

    是的，因为你不知道该方法将如何使用。即使今天仅与列表一起使用，明天也可能有人会做其他事情。就像这样调用它：

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

    在这种情况下，每次调用.First()都需要运行VeryExpensiveFunction()。

    将结果存储在变量中是一个很好的解决方案，或者您可以将该方法声明为SomeMethod(List<Member> members), 或SomeMethod(IReadOnlyList<Member> members)，以防您实际上需要多次迭代它。

    • 0

相关问题