除了yield在Ruby中使用迭代器之外,我还使用它将控制权简单地传递回调用者,然后在被调用的方法中恢复控制.我想在C#中做的事情是类似的.在测试类中,我想获取一个连接实例,创建另一个使用该连接的变量实例,然后将该变量传递给调用方法,以便可以进行调整.然后,我希望控制返回到被调用的方法,以便可以处理连接.我想我想要像Ruby一样的块/闭包.这是一般的想法:

private static MyThing getThing()
{
    using (var connection = new Connection())
    {
        yield return new MyThing(connection);
    }
}

[TestMethod]
public void MyTest1()
{
    // call getThing(), use yielded MyThing, control returns to getThing()
    // for disposal
}

[TestMethod]
public void MyTest2()
{
    // call getThing(), use yielded MyThing, control returns to getThing()
    // for disposal
}

...

这在C#中不起作用; ReSharper告诉我,body getThing不能是迭代器块,因为MyThing它不是迭代器接口类型.这绝对是正确的,但我不想迭代一些列表.我猜我不应该使用,yield如果我不使用迭代器.任何想法,我怎样才能实现在C#此块/关闭的事情,所以我没有给缠上了我的代码MyTest1,MyTest2......与代码getThing()的身上？

我知道os.listdir,但据我所知,它将目录中的所有文件名都存入内存,然后返回列表.我想要的是一种产生文件名,处理它,然后产生下一个文件名的方法,而不是将它们全部读入内存.

有没有办法做到这一点？我担心文件名更改,添加新文件以及使用此类方法删除文件的情况.一些迭代器阻止您在迭代期间修改集合,主要是通过在开始时获取集合状态的快照,并在每个move操作上比较该状态.如果有一个迭代器能够从路径中产生文件名,那么如果有文件系统更改(添加,删除,重命名迭代目录中的文件)修改集合会引发错误吗？

可能有一些情况可能导致迭代器失败,这一切都取决于迭代器如何维持状态.使用S.Lotts示例:

filea.txt
fileb.txt
filec.txt

迭代器产量filea.txt.期间processing,filea.txt被重命名为filey.txt和fileb.txt被重命名为filez.txt.当迭代器试图获取下一个文件时,如果要使用文件名filea.txt找到它的当前位置以便找到下一个文件filea.txt而不存在,会发生什么？它可能无法恢复它在集合中的位置.类似地,如果迭代器fileb.txt在屈服时要获取filea.txt,它可能会查找fileb.txt,失败并产生错误的位置.

如果迭代器能够以某种方式维护索引dir.get_file(0),那么维护位置状态不会受到影响,但是一些文件可能会被遗漏,因为它们的索引可以被移动到迭代器"后面"的索引.

这当然是理论上的,因为似乎没有内置(python)方法迭代目录中的文件.但是,下面有一些很好的答案可以通过使用队列和通知来解决问题.

编辑:

关注的操作系统是Redhat.我的用例是这样的:

进程A不断将文件写入存储位置.进程B(我正在写的那个)将迭代这些文件,根据文件名进行一些处理,并将文件移动到另一个位置.

编辑:

有效的定义:

形容词1.良好的基础或合理的,相关的.

(对不起S.Lott,我无法抗拒).

我已经编辑了上面的段落.

下面是scala中for/yield的标准格式:请注意它需要一个集合 - 其元素驱动迭代.

for (blah <- blahs) yield someThingDependentOnBlah

我有一种情况,循环中会发生不确定的迭代次数.内循环逻辑确定将执行的数量.

while (condition) { some logic that affects the triggering condition } yield blah

每次迭代都会生成一个序列的一个元素 - 就像编程产量一样.建议的方法是什么？

我有一个多线程应用程序,它为几个硬件工具生成线程.每个线程基本上都是一个无限循环(在应用程序的生命周期内),它会轮询硬件以获取新数据,并在每次收集新内容时激活一个事件(传递数据).有一个侦听器类可以合并所有这些乐器,执行一些计算,并通过此计算触发新事件.

但是,我想知道,由于只有一个侦听器,最好IEnumerable<>从这些乐器中公开一个方法,并使用a yield return来返回数据,而不是触发事件.

我想看看是否有人知道这两种方法的差异.特别是,我正在寻找最佳的可靠性,最佳的暂停/取消操作能力,最适合穿线,一般安全等.

另外,使用第二种方法是否仍然可以在IEnumerable单独的线程上运行循环？其中许多仪器都受CPU限制,因此确保每个仪器都在不同的线程上是至关重要的.

我对该sched_yield函数几乎没有任何疑问,因为我发现它在我的代码中没有按预期运行.很多时候,当我尝试通过调用产生它时,我看到同一个线程一次又一次地运行,即使存在其他线程sched_yield.

此外,如果我有多sched_yield核,将为所有核心上运行的线程或仅一个核心运行.例如,我在核心1上运行线程1,2和3,在核心2上运行线程4,5和6,并且sched_yield从线程2调用If ,它将仅由线程1和3替换,或者1,3,4 ,5和6都可能吗？我问这个是因为.Net Thread.Yield只会产生在同一个核心/处理器上运行的线程.

如果我有一个<%= yield %>标签,那么我的所有视图都会在布局中的相同位置呈现.我可以<%= yield %>为不同的视图使用不同的标签吗？我是怎么做到的？谢谢

谁能帮助我理解"收益自我"和"收益率"之间的区别？

class YieldFirstLast
    attr_accessor :first, :last

    def initialize(first = nil, last = nil)
        @first = first
        @last = last
        yield self if block_given?
    end

    def hello
        puts "#{@first} #{@last} says hello!"
    end
end

我有一个python大师的新手问题.

我有一个函数A,它包含很多重复的yield-actions,如下所示:

yield a
yield b
yield c

它看起来像:

def funA():
    …
   yield a
   yield b
   yield c
    …
   yield a
   yield b
   yield c
    …
   yield a
   yield b
   yield c

有没有办法把所有重复的收益率放在函数中并做这样的事情？:

def funA():
    …
   yield funB()
    …
   yield funB()
    …
   yield funB()

更新

yield a
yield b
yield c

这只是一个例子,但在实际应用中,它的更复杂的产量序列在主生成器中重复多次(因此不是关于组织产量的问题),而是关于子生成器.所以我想避免代码重复.

我写了一个应该返回字典的生成函数.但是当我尝试打印字段时,我收到以下错误

print row2['SearchDate']
TypeError: 'generator' object has no attribute '__getitem__'

这是我的代码

from csv import DictReader
import pandas as pd
import numpy as np


def genSearch(SearchInfo):
    for row2 in DictReader(open(SearchInfo)):
        yield row2

train = 'minitrain.csv'

SearchInfo = 'SearchInfo.csv'

row2 = {'SearchID': -1}

for row1 in DictReader(open(train)):
    if 'SearchID' in row1 and 'SearchID' in row2 and row1['SearchID'] == row2['SearchID']:
        x = deepcopy( row1 )
        #x['SearchDate'] = row2['percent']
        x.update(row2)    
        print 'new'
        print x
    else: 
        #call your generator
        row2 = genSearch(SearchInfo)
        print row2['SearchDate']

我希望能够对我最近在调试器中完成的一个片段做一些澄清,但是根本无法理解.

我正在PluralSight上学习C#课程,目前的主题是关于并使用关键字返回a .yieldIEnumerable<T>

我有这个过于基本的函数,它返回一个(一个带有的简单类,和)的IEnumerable集合:VendorsIdCompanyNameEmail

public IEnumerable<Vendor> RetrieveWithIterator()
{
    this.Retrieve(); // <-- I've got a breakpoint here
    foreach(var vendor in _vendors)
    {
        Debug.WriteLine($"Vendor Id: {vendor.VendorId}");
        yield return vendor;
    }
}

我在单元测试中得到了这个代码,我用它来测试函数:

var vendorIterator = repository.RetrieveWithIterator(); // <-- Why don't it enter function?
foreach (var item in vendorIterator) // <-- But starts here?
{
    Debug.WriteLine(item);
}
var actual = vendorIterator.ToList();

我真的无法理解,我确信很多初学者都遇到了同样的问题,这就是为什么初始调用RetrieveWithIterator不会启动函数,而是在我们开始迭代其返回的IEnumerable集合时开始(见评论).