提问



yield关键字是C#中那些继续使我神秘化的关键词之一,而且我从未确信我正确使用它。[25] [26]


以下两段代码中,哪个是首选,为什么?


版本1:使用收益率返回


public static IEnumerable<Product> GetAllProducts()
{
    using (AdventureWorksEntities db = new AdventureWorksEntities())
    {
        var products = from product in db.Product
                       select product;

        foreach (Product product in products)
        {
            yield return product;
        }
    }
}


版本2:返回列表


public static IEnumerable<Product> GetAllProducts()
{
    using (AdventureWorksEntities db = new AdventureWorksEntities())
    {
        var products = from product in db.Product
                       select product;

        return products.ToList<Product>();
    }
}

最佳参考


当我计算列表中的下一个项目(甚至是下一组项目)时,我倾向于使用yield-return。


使用版本2,您必须在返回之前拥有完整列表。
通过使用yield-return,您实际上只需要在返回之前拥有下一个项目。


除此之外,这有助于在更大的时间范围内分散复杂计算的计算成本。例如,如果列表连接到GUI并且用户从未转到最后一页,则永远不会计算列表中的最终项目。


另一种情况,其中yield-return是优选的,如果IEnumerable表示无限集。考虑素数列表,或无限的随机数列表。您永远不能一次返回完整的IEnumerable,因此您使用yield-return以递增方式返回列表。


在您的特定示例中,您有完整的产品列表,因此我将使用版本2。

其它参考1


填充临时列表就像下载整个视频一样,而使用yield就像流式传输视频一样。

其它参考2


作为理解何时应该使用yield的概念性例子,让我们说方法ConsumeLoop()处理由ProduceList()返回/产生的项目:


void ConsumeLoop() {
    foreach (Consumable item in ProduceList())        // might have to wait here
        item.Consume();
}

IEnumerable<Consumable> ProduceList() {
    while (KeepProducing())
        yield return ProduceExpensiveConsumable();    // expensive
}


没有yield,调用ProduceList()可能需要很长时间,因为你必须在返回之前完成列表:


//pseudo-assembly
Produce consumable[0]                   // expensive operation, e.g. disk I/O
Produce consumable[1]                   // waiting...
Produce consumable[2]                   // waiting...
Produce consumable[3]                   // completed the consumable list
Consume consumable[0]                   // start consuming
Consume consumable[1]
Consume consumable[2]
Consume consumable[3]


使用yield,它变得重新排列,有点并行工作:


//pseudo-assembly
Produce consumable[0]
Consume consumable[0]                   // immediately Consume
Produce consumable[1]
Consume consumable[1]                   // consume next
Produce consumable[2]
Consume consumable[2]                   // consume next
Produce consumable[3]
Consume consumable[3]                   // consume next


最后,正如许多人之前已经建议的那样,你应该使用版本2,因为你已经有了完整的列表。

其它参考3


这似乎是一个奇怪的建议,但我通过阅读Python中关于生成器的演示文稿学习了如何在C#中使用yield关键字:David M. Beazley的http://www.dabeaz.com/发生器/Generators.pdf。你不需要了解太多的Python来理解演示文稿 - 我没有。我发现它不仅有助于解释生成器如何工作,而且解释为什么你应该关心。[27]

其它参考4


我知道这是一个老问题,但我想提供一个如何创造性地使用yield关键字的例子。我真的从这种技术中受益。希望这对任何人都有帮助否则谁会偶然发现这个问题。


注意:不要将yield关键字视为构建集合的另一种方式。收益率的很大一部分来自于你的执行暂停
方法或属性,直到调用代码迭代下一个值。这是我的榜样:


使用yield关键字(以及Rob Eisenburg的Caliburn.Micro协同程序实现)允许我表达对这样的Web服务的异步调用:[28]


public IEnumerable<IResult> HandleButtonClick() {
    yield return Show.Busy();

    var loginCall = new LoginResult(wsClient, Username, Password);
    yield return loginCall;
    this.IsLoggedIn = loginCall.Success;

    yield return Show.NotBusy();
}


这样做是打开我的BusyIndi​​cator,在我的Web服务上调用Login方法,将我的IsLoggedIn标志设置为返回值,然后关闭BusyIndi​​cator。


这是如何工作的:IResult有一个Execute方法和一个Completed事件.Caliburn.Micro从调用HandleButtonClick()中获取IEnumerator并将其传递给Coroutine.BeginExecute方法.BeginExecute方法开始迭代IResults。返回第一个IResult,在HandleButtonClick()内暂停执行,BeginExecute()将事件处理程序附加到Completed事件并调用Execute()。IResult.Execute()可以执行同步或异步任务并触发Completed事件完成后。


LoginResult看起来像这样:


public LoginResult : IResult {
    // Constructor to set private members...

    public void Execute(ActionExecutionContext context) {
        wsClient.LoginCompleted += (sender, e) => {
            this.Success = e.Result;
            Completed(this, new ResultCompletionEventArgs());
        };
        wsClient.Login(username, password);
    }

    public event EventHandler<ResultCompletionEventArgs> Completed = delegate { };
    public bool Success { get; private set; }
}


设置这样的东西并逐步执行以观察正在发生的事情可能会有所帮助。


希望这可以帮助别人!我非常喜欢探索可以使用产量的不同方法。

其它参考5


这两段代码实际上做了两件不同的事情。第一个版本将根据您的需要提取成员。第二个版本会将所有结果加载到内存中开始对它做任何事情。


这个问题没有正确或错误的答案。哪一个更可取仅取决于具体情况。例如,如果你有一个时间限制,你必须完成你的查询,你需要做一些半复杂的事情。结果,第二个版本可能更好。但是要注意大的结果集,特别是如果你在32位模式下运行这个代码。在执行这个方法时,我已经多次被OutOfMemory异常所困。


要记住的关键是:差异在于效率。因此,您可能应该选择使代码更简单的方法,并在分析后更改它。

其它参考6


产量有两个很大的用途


它有助于提供自定义迭代而无需创建临时集合。 (加载所有数据和循环)


它有助于进行有状态迭代。 (流媒体)


下面是一个简单的视频,我已经完整演示,以支持上述两点


http://www.youtube.com/watch?v=4fju3xcm21M[29]

其它参考7


这就是Chris Sells在C#编程语言中讲述的那些陈述; [30]



  我有时会忘记收益率与收益率不一样
  可以执行yield return之后的代码。例如,
  第一次返回后的代码永远不能执行:


    int F() {
return 1;
return 2; // Can never be executed
}

  
  相反,这里第一次收益率返回后的代码可以是
  执行:


IEnumerable<int> F() {
yield return 1;
yield return 2; // Can be executed
}

  
  这经常在if语句中咬我:


IEnumerable<int> F() {
if(...) { yield return 1; } // I mean this to be the only
// thing returned
yield return 2; // Oops!
}

  
  在这些情况下,记住收益率回报并不像最终那样
  回报很有帮助。


其它参考8


对于需要迭代数百万个对象的算法,yield yield非常强大。请考虑以下示例,您需要计算rideshare的可能行程。首先我们生成可能的旅行:


    static IEnumerable<Trip> CreatePossibleTrips()
    {
        for (int i = 0; i < 1000000; i++)
        {
            yield return new Trip
            {
                Id = i.ToString(),
                Driver = new Driver { Id = i.ToString() }
            };
        }
    }


然后遍历每次旅行:


    static void Main(string[] args)
    {
        foreach (var trip in CreatePossibleTrips(trips))
        {
            // possible trip is actually calculated only at this point, because of yield
            if (IsTripGood(trip))
            {
                // match good trip
            }
        }
    }


如果使用List而不是yield,则需要将100万个对象分配给内存(~190mb),这个简单的例子需要大约1400ms才能运行。但是,如果你使用yield,你不需要将所有这些临时对象放到内存中,你将获得明显更快的算法速度:这个例子只需要约400毫秒就可以完全没有内存消耗。

其它参考9


假设您的产品LINQ类使用类似的枚举/迭代产量,第一个版本更有效,因为它每次迭代时只产生一个值。


第二个示例是使用ToList()方法将枚举数/迭代器转换为列表。这意味着它手动迭代枚举器中的所有项目,然后返回一个平面列表。

其它参考10


除了这一点之外,这有点类似,但由于这个问题被标记为最佳实践,我将继续投入我的两分钱。对于这种类型的东西,我更喜欢把它变成一个属性:


public static IEnumerable<Product> AllProducts
{
    get {
        using (AdventureWorksEntities db = new AdventureWorksEntities()) {
            var products = from product in db.Product
                           select product;

            return products;
        }
    }
}


当然,这是一个更多的锅炉板,但使用它的代码看起来会更清除:


prices = Whatever.AllProducts.Select (product => product.price);


VS


prices = Whatever.GetAllProducts().Select (product => product.price);


注意:对于任何可能需要一段时间才能完成工作的方法,我不会这样做。

其它参考11


那怎么样?


public static IEnumerable<Product> GetAllProducts()
{
    using (AdventureWorksEntities db = new AdventureWorksEntities())
    {
        var products = from product in db.Product
                       select product;

        return products.ToList();
    }
}


我想这更干净了。不过,我手头没有VS2008。
在任何情况下,如果Products实现IEnumerable(似乎 - 它在foreach语句中使用),我将直接返回它。

其它参考12


在这种情况下,我会使用代码的第2版。由于您拥有可用产品的完整列表以及此方法调用的消费者所期望的内容,因此需要将完整信息发送回调用方。


如果此方法的调用者一次需要一个信息并且下一个信息的消耗是按需的,那么使用yield return将是有益的,这将确保执行命令将在返回给调用者时返回给调用者。提供一个信息单位。


可以使用收益率回报的一些示例是:



  1. 复杂的逐步计算,其中调用者一次等待一个步骤的数据

  2. 在GUI中进行分页 - 用户可能永远无法访问最后一页,只需要在当前页面上公开信息子集



要回答你的问题,我会使用版本2。

其它参考13


直接返回列表。优点:



  • 更清楚

  • 该列表可重复使用。 (迭代器不是)实际上不是真的,谢谢Jon



您应该使用迭代器(yield),当您认为您可能不必一直迭代到列表的末尾,或者它没有结束时。例如,客户端调用将要搜索第一个满足某些谓词的产品,你可能会考虑使用迭代器,虽然这是一个人为的例子,并且可能有更好的方法来实现它。基本上,如果您事先知道需要计算整个列表,请事先做好。如果您认为它不会t,那么请考虑使用迭代器版本。

其它参考14


yield return keyphrase用于维护特定集合的状态机。只要CLR看到正在使用的yield return keyphrase,CLR就会对该段代码实现Enumerator模式。这种类型的实现有助于开发人员处理所有类型的管道,否则我们将缺少关键字。


假设开发人员正在过滤一些集合,迭代集合,然后在一些新集合中提取这些对象。这种管道非常单调。


有关此关键字的更多信息,请参阅本文。[32]

其它参考15


收益的使用类似于关键字返回,但它会返回生成器。而生成器对象只会遍历一次[33]


产量有两个好处:



  1. 您不需要两次读取这些值;

  2. 您可以获得许多子节点,但不必将它们全部放在内存中。



还有另一个明确的解释可能对你有帮助。[34]