标签: enumerator

看起来将列表的枚举器传递给函数"byval"与传递"byref"完全不同.基本上,常规的"byval"传递不会改变调用者的"enumerator.Current值",即使该函数使枚举器前进.我想知道是否有人知道为什么会这样？枚举器是一个整数的原语,没有对象引用,因此对它的更改不会反映在调用者中吗？

以下是示例代码:

这个函数是byval,并且陷入无限循环,吐出"1"消息框,因为枚举器的"当前"从未超过5:

Public Sub listItemsUsingByValFunction()
    Dim list As New List(Of Integer)(New Integer() {1, 2, 3, 4, 5, 6, 7, 8, 9, 10})

    Dim enumerator = list.GetEnumerator()
    enumerator.MoveNext()
    While enumerator.Current <= 5
        listFirstItemByVal(enumerator)
    End While
End Sub
Private Sub listFirstItemByVal(ByVal enumerator As List(Of Integer).Enumerator)
    MsgBox(enumerator.Current)
    enumerator.MoveNext()
End Sub

另一方面,这可以像人们期望的那样工作:

Public Sub listItemsUsingByRefFunction()
    Dim list As New List(Of Integer)(New Integer() {1, 2, 3, 4, 5, 6, 7, 8, 9, 10})

    Dim enumerator = list.GetEnumerator()
    enumerator.MoveNext()
    While enumerator.Current <= 5
        listFirstItemByRef(enumerator)
    End …

考虑一个像这样的简单枚举器:

natural_numbers = Enumerator.new do |yielder|
  number = 1
  loop do
    yielder.yield number
    number += 1
  end
end

我的问题是:为什么ruby要求我们在yielder对象上调用yield？换句话说:为什么我们不能代替yielder.yield number用yield number？在这个例子中,如果允许的话,它看起来是一样的.有没有以非平凡的方式使用yielder的例子？如果是这样,你能给一个吗？如果没有,yielder的目的是什么？

谢谢.

我正在实施AWS S3文件传递API.我被迫将S3的S3ObjectInputStream中的字节流式传输到浏览器.我们有一个用例用云端服务文件不是一个选项(主要是本地开发)

我有一个InputStream,所以最明显的事情是使用带有Enumerator.fromStream()的Ok.chunked,但Enumerator.fromStream()有一个非常明确的警告,即流不应该很慢.我假设AWS S3ObjectInputStream可能是最慢的流之一.

http://www.playframework.com/documentation/2.2.x/api/scala/index.html#play.api.libs.iteratee.Enumerator$

def fromStream(input: InputStream, chunkSize: Int = 1024 * 8)
              (implicit ec: ExecutionContext): Enumerator[Array[Byte]]

Create an enumerator from the given input stream.

This enumerator will block on reading the input stream, in the default iteratee
thread pool. Care must therefore be taken to ensure that this isn't a 
slow stream. If using this with slow input streams, consider setting the value
of iteratee-threadpool-size to a value appropriate for handling the blocking.

所以我想知道最安全的方法是避免线程饥饿并将文件流式传输到浏览器而不将整个文件保存在内存中.

是否有其他方法可以从InputStream获取枚举器(或我们可以在结果中发送的内容)？

在我们的项目中,我们使用的是ReactiveMongo用Play 2.2.1.

问题是,Enumerator[A]返回的形式的数据流ReactiveMongo实际上是一个值对象流,它们没有逗号分隔,并且没有流开始和结束注释,可以视为数组打开和关闭声明.

这会给JSON消费者带来问题JS client,因为预期的格式是 [A1,A2, ...]

所以我们跳入了箍,并通过检查将我们Enumeratee[A]改为Enumerator[String],如果它是第一个元素,或者不是:

    var first:Boolean = true
    val aToStrs = (as.map(a => {
        if(first) {
            first = false;
            Json.stringify(Json.toJson(a))
        } else {
            "," + Json.stringify(Json.toJson(a))
        }
   }))
   Ok.chunked(
       Enumerator.enumInput(Input.El("[")) andThen
       aToStrs andThen
       Enumerator.enumInput(Input.El("]")) andThen
       Enumerator.enumInput(Input.EOF)
   )

这有效,但感觉就像发明轮子一样.

对于这个常见问题,有没有更好的解决方案？

我认为无限枚举器对于编写FP样式脚本非常方便,但我还没有找到一种在Ruby中构造这种结构的舒适方法.

我知道我可以明确地构建它:

a = Enumerator.new do |y|
    i = 0
    loop do
        y << i += 1
    end
end
a.next  #=> 1
a.next  #=> 2
a.next  #=> 3
...

但这对于这样一个简单的结构来说很烦人.

另一种方法是使用的"黑客" Float::INFINITY:

b = (1..Float::INFINITY).each
b = (1..1.0/0.0).each

这两个可能是我能给出的最笨拙的解决方案.虽然我想知道是否还有其他更优雅的方法来构建无限的枚举器.(顺便说一句,为什么Ruby不能制作inf或infinity作为文字Float::INFINITY？)

假设我有一些在方法IEnumerator<T>内部进行大量处理的方法MoveNext()。

从该枚举器消耗的代码不仅消耗与可用数据一样快的速度，而且偶尔会等待（其细节与我的问题无关）以便同步需要恢复消耗的时间。但是当它下一次调用 时MoveNext()，它需要尽快获得数据。

一种方法是将整个流预先消耗到某个列表或数组结构中以进行即时枚举。然而，这会浪费内存，因为在任何单个时间点，只有一项正在使用，并且在整个数据无法放入内存的情况下，这将是禁止的。

那么，.net 中是否有一些通用的东西可以以某种方式包装枚举器/枚举，以便它提前异步地预迭代底层枚举器几个项目并缓冲结果，以便它的缓冲区中始终有许多可用的项目，并且调用 MoveNext 永远不必等待？显然，消耗的项目（即由调用者的后续 MoveNext 迭代的项目）将从缓冲区中删除。

注意，我正在尝试做的部分也称为BackPressure，并且在 Rx 世界中，已经在RxJava中实现，并且正在Rx.NET中进行讨论。Rx（推送数据的可观察量）可以被认为是枚举器的相反方法（枚举器允许拉取数据）。在拉动方法中，背压相对容易，正如我的回答所示：只需暂停消耗即可。推动的时候比较困难，需要额外的反馈机制。

我试图循环哈希数组.当我到达我获取Enumerator开始循环的点时,我收到以下错误:

undefined method `[]' for nil:NilClass

我的代码如下所示:

def extraireAttributs (attributsParam)
  classeTrouvee = false
  scanTrouve = false
  ownerOSTrouve = false
  ownerAppTrouve = false
  resultat = Hash.new(0)
  attributs = Array(attributsParam)

  attributs.each do |attribut| #CRASHES HERE!!!
    typeAttribut = attribut['objectTypeAttribute']
    [...]

我检查了调试模式以确保attributsParams参数和attributs变量不是nil或空.两者(因为它们是相同的!)包含59个Hashes对象,但我仍然无法在Array上获得Enumerator.

为什么我一直收到这个错误？

谢谢!

考虑以下基准：

[MemoryDiagnoser]
public class EnumerableBenchmark
{
    private IEnumerable<string> _emptyArray = new string[0];
    private IEnumerable<string> _notEmptyArray = new string[1];

    [Benchmark]
    public IEnumerator<string> ArrayEmpty()
    {
        return _emptyArray.GetEnumerator();
    }

    [Benchmark]
    public IEnumerator<string> ArrayNotEmpty()
    {
        return _notEmptyArray.GetEnumerator();
    }
}

BenchmarkDotNet 在 .net framework 4.8 和 .net core 3.1 上报告了以下结果：

// * Summary *

BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19041.329 (2004/?/20H1)
Intel Core i7-9750H CPU 2.60GHz, 1 CPU, 12 logical and 6 physical cores
.NET Core SDK=3.1.301
  [Host]     : .NET Core 3.1.5 (CoreCLR 4.700.20.26901, CoreFX 4.700.20.27001), X64 RyuJIT …

考虑以下代码：

[1,2,3].map.with_index { |x, i| x * i }
# => [0,2,6]

这到底是如何运作的？

我的思维模型map是它迭代并在每个元素上应用一个函数。是否with_index以某种方式将函数传递给 enumerator [1,2,3].map，在这种情况下该函数会是什么？

这个SO 线程显示了枚举器如何传递数据，但没有回答问题。事实上，如果你替换map为each那么行为是不同的：

[1,2,3].each.with_index { |x, i| x * i }
# => [1,2,3]

map除了携带要迭代的数据之外，似乎还携带必须应用函数的信息。这是如何运作的？

有没有办法在.NET(或某种标准扩展方法)中提出枚举问题？

例如,当前项是枚举中的第一个或最后一个项:

string s = "";

foreach (var person in PeopleListEnumerator) {

  if (PeopleListEnumerator.IsFirstItem) s += "[";

  s += person.ToString();

  if (!PeopleListEnumerator.IsLastItem) s += ",";
  else s += "]";
}