с помощью урожая в C# как я был бы в Ruby

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 используется для получения значение для вызывающего , а в Ruby yield используется для передачи элемента управления аргументу блока

Фактически, в Ruby , yield - это просто ярлык для Proc # call .

Представьте, если бы yield не существовало. Как бы вы написали метод if на Ruby? Это будет выглядеть так:

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 # call , что делает его немного лучше:

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

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

Однако Юкихиро Мацумото заметил, что подавляющее большинство процедуры высшего порядка принимают только один аргумент процедуры. (Тем более, что 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

Однако, поскольку мы больше не есть имя, на которое мы можем отправлять сообщения, нам нужен другой способ. И снова мы получаем одно из тех решений 80/20, которые так типичны для Ruby: существует тонн вещей, которые можно было бы сделать с блоком: преобразовать его, сохранить в атрибуте, передать его в другой метод, изучите, распечатайте… Однако, по далеко , наиболее распространенным является его вызов. Итак, matz добавил еще один специальный сокращенный синтаксис именно для этого распространенного случая: yield означает « call блок, который был передан методу». Следовательно, нам не нужно имя:

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