在 C# 中使用 Yield，就像在 Ruby 中一样

Question

除了在 Ruby 中对迭代器使用 yield 之外，我还使用它在恢复被调用方法中的控制之前将控制权短暂地传递回调用者。我想在 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 告诉我 getThing 的主体不能是迭代器块，因为 MyThing 不是迭代器接口类型。这绝对是真的，但我不想遍历某些列表。我猜如果我不使用迭代器，我不应该使用 yield 。知道如何在 C# 中实现此块/闭包，这样我就不必将代码包装在 MyTest1、MyTest2... 中，并将代码放在 < code>getThing() 的主体？

Answer 1

您想要的是 lambda 表达式，类似于：

// not named GetThing because it doesn't return anything
private static void Thing(Action<MyThing> thing)
{
    using (var connection = new Connection())
    {
        thing(new MyThing(connection));
    }
}

// ...
// you call it like this
Thing(t=>{
  t.Read();
  t.Sing();
  t.Laugh();
});

这捕获 t 的方式与 Ruby 中 yield 的方式相同。 C# yield 不同，它构造可以迭代的生成器。

Answer 2

您说您想要使用 C# 的 yield 关键字，就像使用 Ruby 的 yield 关键字一样。您似乎对两者实际上所做的事情有点困惑：两者绝对没有任何关系，您所要求的根本不可能。

C# yield 关键字不是相当于 Ruby yield 关键字的 C# 关键字。事实上，没有相当于 C# 中的 Ruby yield 关键字。 Ruby 中相当于 C# 的 yield 关键字的不是 yield 关键字，它是 Enumerator:: Yielder#yield 方法（也别名为 Enumerator::Yielder#<<）。

IOW，它用于返回迭代器的下一个元素。下面是官方 MSDN 文档中的一个删节示例：

public static IEnumerable Power(int number, int exponent) {
    var counter = 0;
    var result = 1;
    while (counter++ < exponent) {
        result *= number;
        yield return result; }}

像这样使用它：

foreach (int i in Power(2, 8)) { Console.Write("{0} ", i); }

Ruby 等效项类似于：

def power(number, exponent)
  Enumerator.new do |yielder|
    result = 1
    1.upto(exponent-1) { yielder.yield result *= number } end end

puts power(2, 8).to_a

在 C# 中，yield 用于生成 值 到 < em>调用者，在 Ruby 中，yield 用于将控制交给块参数

事实上，在 Ruby 中，>yield 只是 Proc#call 的快捷方式。

想象一下，如果 yield 不存在。如何在 Ruby 中编写 if 方法？它看起来像这样：

class TrueClass
  def if(code)
    code.call
  end
end

class FalseClass
  def if(_); end
end

true.if(lambda { puts "It's true!" })

这有点麻烦。在 Ruby 1.9 中，我们获得了 proc 文字和 Proc#call 的快捷语法，这使得它变得更好一点：

class TrueClass
  def if(code)
    code.()
  end
end

true.if(->{ puts "It's true!' })

但是，Yukihiro Matsumoto 注意到，绝大多数高阶过程仅采用一个过程参数。 （特别是因为 Ruby 在语言中内置了多个控制流结构，否则需要多个过程参数，例如 if-then-else 需要两个和 case-when 这将需要 n 个参数。）因此，他创建了一种专门的方法来传递恰好一个过程参数：块。 （事实上​​，我们一开始就已经看到了这样的例子，因为 Kernel#lambda 实际上只是一个普通的方法，它接受一个块并返回一个 Proc。）

class TrueClass
  def if(&code)
    code.()
  end
end

true.if { puts "It's true!" }

现在，由于我们只能将一个块传递到方法中，因此我们实际上不需要显式命名该变量，因为无论如何都不会存在歧义：

def if
  ???.() # But what do we put here? We don't have a name to call #call on!
end

但是，由于我们现在不再有可以发送的名称消息，我们需要其他方式。再次，我们得到了 Ruby 典型的 80/20 解决方案之一：人们可能想要对块做很多事情：转换它，将它存储在属性中，将它传递给另一个方法，检查它，打印它......但是，到目前为止，最常见的事情是调用它。因此，matz 针对这种常见情况添加了另一种专门的快捷语法：yield 表示“调用传递给方法的块”。因此，我们不需要名称：

def if; yield end

那么，C# 中相当于 Ruby 的 yield 关键字的是什么？好吧，让我们回到第一个 Ruby 示例，其中我们显式地将过程作为参数传递：

def foo(bar)
  bar.('StackOverflow')
end

foo ->name { puts "Higher-order Hello World from #{name}!" }

C# 等效项完全相同：

void Foo(Action<string> bar) => bar("StackOverflow")

Foo(name => { Console.WriteLine("Higher-order Hello World from {0]!", name); })

Answer 3

我可能会将委托传递给迭代器。

delegate void Action(MyThing myThing);
private static void forEachThing(Action action) 
{ 
    using (var connection = new Connection()) 
    { 
        action(new MyThing(connection));
    } 
}

Answer 4

C# 中的 yield 专门用于返回迭代集合的位。具体来说，您的函数必须返回 IEnumerable 或 IEnumerable 才能使 yield 正常工作，并且它应该在 内部使用。代码>foreach循环。它是 C# 中非常具体的构造，不能按照您尝试的方式使用。

我不确定是否还有其他可以使用的构造，可能是带有 lambda 表达式的构造。

Answer 5

您可以让 GetThing 获取包含要执行的代码的委托，然后从其他函数传递匿名方法。