标签: deferred-execution

我有一个正常的Django网站运行.此外,还有另一个扭曲的过程,它使用Django的ORM监听Jabber存在通知并更新Django DB.

到目前为止,它只是调用相应的Django模型(在正确设置了设置环境之后).但是,这会阻止Twisted应用程序,这不是我想要的.

由于我不熟悉,我不知道,使用延迟以非阻塞方式访问Django DB(通过其ORM)的最佳方法是什么.

1. deferredGenerator？
2. twisted.enterprise.adbapi？(规避ORM？)
3. ???

如果解析在线消息,我想在Django DB中保存具有jid_str的用户在线/离线(使用Django模型UserProfile).我用这个功能做到了:

def django_useravailable(jid_str, user_available):
    try:
        userhost = jid.JID(jid_str).userhost()
        user = UserProfile.objects.get(im_jabber_name=userhost)
        user.im_jabber_online = user_available
        user.save()
        return jid_str, user_available
    except Exception, e:
        print e
    raise jid_str, user_available,e

Run Code Online (Sandbox Code Playgroud)

目前,我用以下方式调用它:

d = threads.deferToThread(django_useravailable, from_attr, user_available)
d.addCallback(self.success)
d.addErrback(self.failure)

gometalinter并errcheck返回一个关于延迟返回变量的函数的警告.

Web请求中的示例:

defer r.Body.Close()

在这种情况下,Close返回一个错误变量并且不会检查它.

将其推迟到另一个函数中是最好的方法/惯用法吗？

defer func() {
    err := r.Body.Close()
    if err != nil {
        // fmt, panic or whatever
    }
}()

假设我们有一个如下所示的方法:

public IEnumerable<Dog> GrowAll(this IEnumerable<Puppy> puppies)
{
    if(subjects == null)
        throw new ArgumentNullException("subjects");

    foreach(var puppy in puppies)
        yield return puppy.Grow();
}

如果我通过这样做测试:

Puppy[] puppies = null;
Assert.Throws<ArgumentNullException>(() => puppies.GrowAll());

测试将失败说它

预期:<System.ArgumentNullException>
但是: null

我可以通过改变测试来解决这个问题

Puppy[] puppies = null;
Assert.Throws<ArgumentNullException>(() => puppies.GrowAll().ToArray());

这通常是你通常会这样做的吗？或者有更好的方法来编写测试吗？或者也许是一种更好的方法来编写方法本身？

尝试使用内置Select方法做同样的ToArray事情,即使没有或类似的事情它也失败了,所以显然你可以做些什么......我只是不知道:p

今天我读到defer了Go语言中的陈述:

一个延迟声明推动一个函数调用到列表中.在周围函数返回后执行已保存调用的列表.延迟通常用于简化执行各种清理操作的功能.

我认为在Objective-C中实现类似的东西会很有趣.你知道怎么做吗？我考虑过调度终结器,自动释放的对象和C++析构函数.

自动释放的对象:

@interface Defer : NSObject {}
+ (id) withCode: (dispatch_block_t) block;
@end

@implementation Defer
- (void) dealloc {
    block();
    [super dealloc];
}
@end

#define defer(__x) [Defer withCode:^{__x}]

- (void) function
{
    defer(NSLog(@"Done"));
    …
}

自动释放的对象似乎是至少持续到函数末尾的唯一解决方案,因为其他解决方案将在当前范围结束时触发.另一方面,他们可以在记忆中停留更长时间,这将是一个麻烦.

Dispatch终结器是我的第一个想法,因为块存在于堆栈中,因此当堆栈展开时我可以轻松地执行某些操作.但是在浏览文档后看起来我不能将一个简单的"析构函数"函数附加到块中,是吗？

C++析构函数大致相同,我会创建一个基于堆栈的对象,其中一个块在析构函数运行时执行.这会将普通.m文件转换为Objective-C++ 有一个丑陋的缺点吗？

我真的不考虑在生产中使用这些东西,我只是对各种解决方案感兴趣.你能想出一些有效但没有明显缺点的东西吗？基于范围和基于功能的解决方案都很有趣.

我正在开发一个使用新Web API的项目,我注意到有人从Get方法返回IQueryable <T>.

我的理解是IQueryable对于提高性能(延迟执行)很有用,但我不认为HTTP连接另一端的客户端能够利用它.

我的直觉告诉我,这应该是IEnumberable <T>.我这是对的吗？

我通过实验发现创建一个持续时间为0的计时器允许我将工作推迟到事件队列中.我非常喜欢这个功能,因为它可以避免很多令人讨厌的重入问题.这种有意识的功能是否会改变？它可以添加到文档中吗？如果没有,是否有支持的方式来做到这一点？

所以,这似乎是一个边缘情况,但我只是想知道这是否可能.我所拥有的是静态集和延迟集的组合IEnumerable- 例如:

public IEnumerable<T> MakeMyQuery<T>()
{
    // returns a List<T>
    var someStaticData = LoadMyStaticDataFromDatabase();

    // Returns IEnumerable<T>, but from another resource
    var deferredQuery = CreateADeferredQueryUsingYieldReturn(); 

    return someStaticData.Concat(deferredQuery);
}

所以这里发生的是当我调用.Take(someNumber)我的枚举时,它会在尝试评估延迟组件之前首先从我的静态数据返回元素 - 实际上,我已经"隐藏"了一些可能耗时的生成任务后面的任务,如果我从来不需要获取这些元素,因为LINQ的延迟特性,它们实际上永远不会被评估.

但是,我不认为可以缓存此查询以供以后使用(我不相信Iterator的状态将保留在缓存中,对吧？)或者是否有一种简单的方法可以在不将结果枚举到保存？

理想情况下,我的流程是这样的:

public List<T> SomeMethod<T>(int numberOfGuys)
{
     IEnumerable<T> query = null;

     if(// Is in Cache)
       query = Cache["MyQuery"];
     else
     {
         query = MakeMyQuery();
         Cache["MyQuery"] = query;
     }

     return query.Take(numberOfGuys).ToList();
}

所以我可以反复使用相同的查询来请求数据,但可能永远不必重新查询数据库.有没有办法做到这一点？

这是一个由两部分组成的Python问题。第一部分是关于美学，第二部分是关于实施。到目前为止我所使用的代码示例附在底部。

问题。

我正在尝试设计一个 python 模块/类，它使我能够进行惰性评估/延迟计算。设置这些计算后，我希望能够准确确定答案为何如此，并修改函数的输入并重新计算输出，而无需重新定义中间变量。

本质上，我希望能够做尽可能接近的事情：

>>> a=3
>>> b=5
>>> c=a+b
>>> c
8
>>> a = 6
>>> c
11

和类似的东西

>>> c.calculation
'a [ 6 ]  + b [ 5 ] = 11'

现在我对循环依赖关系还没有那么大惊小怪，我最接近上面的是：

a = constant(2)
b = constant(3)
c = a + b
d = a * b

这给了我这样的东西：

c is 5 [ 2 <built-in function __add__> 3 ]
d is 6 [ 2 <built-in function __mul__> 3 ]

这并不完美，但已经很接近了。然后我更改 a 和 b 的值以重新计算 c,d …

请考虑以下情形

private static ConcurrentDictionary<string, ConcurrentDictionary<string, string>> CachedData;

多个线程通过方法调用访问此变量

ConcurrentDictionary<string, string> dic = CachedData.GetorAdd(key, HeavyDataLoadMethod())

此方法执行一些重量级操作以检索数据

private ConcurrentDictionary<string, string> HeavyDataLoadMethod()
{
        var data = new ConcurrentDictionary<string,string>(SomeLoad());
        foreach ( var item in OtherLoad())
           //Operations on data
        return data;
}

我在这里的问题是,如果我使用GetorAdd了HeavyDataLoadMethod获取即使它不需要执行.

我想知道在这种情况下是否有某种方法可以利用延迟执行并使HeavyDataLoadMethod延迟执行,因此在真正需要之前不执行它.

(是的,我知道这就像使用ContainsKey检查一样简单而忘记它,但我对这种方法很好奇)

我正在尝试处理与 MongoDB 的重新连接。为此，我尝试将每个操作执行三次（以防因 io.EOF 失败）

type MongoDB struct {
    session *mgo.Session
    DB      *mgo.Database
}

func (d MongoDB) performWithReconnect(collection string, 
operation func(*mgo.Collection) error) error {
    var err error
    for i := 0; i < 3; i++ {
        session := d.session.Copy()
        defer session.Close()
        err = operation(session.DB(Config.MongoDb).C(collection))
        if err == io.EOF{
            continue
        }
        if err == nil{
            return err
        }
    }
    return err
}

所以问题是关于延迟。它会像我想象的那样关闭所有会话还是会以其他方式表现？如果您知道一些处理这种不同方式的良好实践，我将很乐意阅读它们。