标签: deferred-execution

假设我有两个(或更多)IEnumerable<T>元素.每个IEnumerable都有另一种类型T.列表可能非常长,不应完全加载到内存中.

IEnumerable<int> ints = getManyInts();
IEnumerable<string> strings = getSomeStrings();
IEnumerable<DateTime> dates = getSomeDates();

我想要做的是迭代这些列表,并获得一个包含一个int,一个字符串和每个步骤一个DateTime的项目,直到达到最长或最短列表的末尾.两种情况都应该得到支持(bool param最长与最短等).对于较短列表中不可用的每个项目(因为已经达到结束),我希望默认值.

for(Tuple<int,string,DateTime> item in 
    Foo.Combine<int,string,DateTime>(ints, strings, dates))
{
    int i=item.Item1;
    string s=item.Item2;
    DateTime d=item.Item3;
}

是否可以使用延迟执行linq执行此操作？我知道使用IEnumerator直接结合yield return的解决方案.请参阅如何在.NET 2中同时迭代两个IEnumerables

基于以下代码:

 var grouped = filters.GroupBy(p => p.PropertyName);
                 int numOfRowElements = grouped.Count();
     foreach (IGrouping<string, PropertyFilter> filter in grouped)
                {


                    foreach (var propertyFilter in filter)
                    {
                        // do something
                    }

                }

在过滤List的过程中,我的理解是调用IEnumerable.Count()会强制执行查询.这个执行的结果是存储在分组变量中,然后在foreach循环中使用,或者foreach循环是否强制查询再次执行？这样做会更好吗？

 var grouped = filters.GroupBy(p => p.PropertyName).ToList();
  int numOfRowElements = grouped.Count;
     foreach (IGrouping<string, PropertyFilter> filter in grouped)
                {


                    foreach (var propertyFilter in filter)
                    {
                        // do something
                    }

                }

TIA.

我一直想知道是否可以在 Lua 中实现延迟执行（.NET Linq 风格），只是为了好玩。

在 .NET 中，我们可以创建一系列元素，称为IEnumerable. 然后可以通过各种方式过滤这些元素，例如 map/reduce ( Select(predicate), Where(predicate))，但这些过滤器的计算仅在您枚举 IEnumerable 时执行 - 它被推迟。

我一直在尝试在 Lua 中实现类似的功能，尽管我对 Lua 很生疏并且已经有一段时间没有接触它了。我想避免使用已经为我执行此操作的库，因为我希望能够尽可能在纯 Lua 中执行此操作。

我的想法是，也许可以使用协程。

Enumerable = {

  -- Create an iterator and utilize it to iterate
  -- over the Enumerable. This should be called from
  -- a "for" loop.
  each = function(self)
    local itr = Enumerable.iterator(self)
    while coroutine.status(itr) ~= 'dead' do
      return function() 
        success, yield = coroutine.resume(itr)
        if success then
          return yield
        else
          error(1, "error …

据我了解，异步脚本是在文档解析完成之前执行的，并在之后延迟脚本。但它们与 window.onload 事件的关系又如何呢？

如果我理解正确的话，异步脚本保证在窗口加载之前运行，并且延迟脚本可以在之后执行。是对的吗？或者这两种脚本总是在窗口加载之前执行？

对于下面的代码段,当收到^ C时,不会进行延迟呼叫.清理是否可能引入竞争条件？如果是,那么在接收中断时可能有更好的清理模式？

  func fn() {
    // some code
    defer cleanup()
    go func() {
       c := make(chan os.Signal, 1)
       signal.Notify(c, os.Interrupt)

       // Block until a signal is received.
       _ = <-c
       cleanup()
     }
     for {
        // Infinite loop. Returns iff an error is encountered in the 
        // body
     }
}

我正在尝试使用列表理解为延迟执行创建一个 lambda 列表。下面是一个简单的例子。

def func_a(message: str) -> None:
    print('a: ' + message)
    
def func_b(message: str) -> None:
    print('b: ' + message)

msg = 'some message'
funcs = [func_a, func_b]
funcs_w_args = [lambda : func(msg) for func in funcs]

for func in funcs_w_args:
    func()

结果是

b: some message
b: some message

而想要的结果应该是

a: some message
b: some message

我哪里错了？

我的谷歌App Engine应用程序被添加了大量的延迟任务到任务队列.任务计划每x秒运行一次.如果我正确理解了bucket-size属性b,则高值将阻止延迟任务运行,直到添加了b任务.但是,有一个接近实时的要求,即任务按计划运行.我不希望在达到桶大小之前阻止任务.相反,他们应该尽可能接近他们的预定时间.

为了支持这个用例,我应该使用1的桶大小和500 的速率(这是当前的最大速率)吗？还有哪些方法可以支持这个？谢谢!

当尝试将日志设置代码移动到单独的函数时,我遇到无法从main函数中隐藏目标文件对象.在下面的INCORRECT简化示例中,尝试通过单个函数调用设置日志写入Stderr和文件:

package main

import (
    "io"
    "log"
    "os"
)

func SetupLogging() {
    logFile, err := os.OpenFile("test.log", os.O_APPEND|os.O_CREATE, 0666)
    if err != nil {
        log.Panicln(err)
    }
    defer logFile.Close()

    log.SetOutput(io.MultiWriter(os.Stderr, logFile))
}

func main() {
    SetupLogging()
    log.Println("Test message")
}

显然是不起作用因为defer在SetupLogging函数结束时关闭日志文件.

下面的一个工作示例添加了额外的代码,如果在较大的应用程序中重复作为模式,IMHO会失去一些清晰度:

package main

import (
    "io"
    "log"
    "os"
)

func SetupLogging() *os.File {
    logFile, err := os.OpenFile("test.log", os.O_APPEND|os.O_CREATE, 0666)
    if err != nil {
        log.Panicln(err)
    }

    log.SetOutput(io.MultiWriter(os.Stderr, logFile))
    return logFile
}

func main() { …

添加bool distinct到方法Splitter并检查distinct is true代码是否破坏后.问题现在而不是字典IEnumerable<string>,但是应该是Dictionary<string, int>.怎么可以解决？

这是错误:

无法将类型'System.Collections.Generic.IEnumerable'隐式转换为'System.Collections.Generic.Dictionary'.存在显式转换(您是否错过了演员？)

和代码:

private Dictionary<string, int> Splitter(string[] file, bool distinct)
{
    var query = file
        .SelectMany(i => File.ReadLines(i)
        .SelectMany(line => line.Split(new[] {' '}, StringSplitOptions.RemoveEmptyEntries))
        .AsParallel()
        .Select(word => word.ToLower())
        .Where(word => !StopWords.Contains(word))
        .Where(word => !StopWordsPl.Contains(word))
        .Where(word => !PopulatNetworkWords.Contains(word))
        .Where(word => !word.All(char.IsDigit)));
        if (distinct)
        {
        query = query.Distinct();
        }

       query.GroupBy(word => word)
            .ToDictionary(g => g.Key, g => g.Count());
       return query;
}

我最近一直在阅读有关延迟执行、LINQ、一般查询等的文章和文档，并且经常出现“对象被枚举”这一短语。有人可以解释当一个对象被枚举时会发生什么吗？

示例文章。

该方法是通过使用延迟执行来实现的。立即返回值是一个对象，它存储执行操作所需的所有信息。在通过直接调用其 GetEnumerator 方法或使用 Visual C# 中的 foreach 枚举对象之前，不会执行此方法表示的查询