Perché non possiamo chiamare due volte un ritorto differito?

Question

Dalla seguente guida: http://krondo.com/blog/?p=1682

Deferreds aiutano a evitare una delle insidie ​​che abbiamo identificato con la programmazione di callback. Quando usiamo un comando differito per gestire i nostri callback, non possiamo semplicemente commettere l'errore di chiamare sia il callback che l'errback, o invocare il callback ventisette volte. Possiamo provare, ma il differito solleverà un'eccezione indietro a noi, invece di passare il nostro errore sui callback stessi

Qualcuno può darmi una spiegazione migliore?

Ho notato che non funzionerebbe comunque perché nella maggior parte dei casi in questo tutorial la callback di fine chiama anche reactor.stop(). Ma perché, però, non ha senso chiamare due volte una differita? Perché è diverso dal chiamare di nuovo una catena di metodi?

Answer 1

A Deferred A rappresenta il risultato di una richiesta che potrebbe essere disponibile (ora o in futuro) ma non è sicuramente disponibile ora

Risultati flusso tramite Deferred s, tramite la loro catena di richiamata. Per esempio, in un programma sincrona, si potrebbe avere qualcosa di simile:

response_bytes = make_request(...) 
response_dict = parse_json(response_bytes) 
response_object = construct_object(response_dict) 
return response_object.method() 

Tradotto in codice che restituisce un Deferred, questo è:

response_bytes_later = make_request_async(...) 
response_dict_later = response_bytes_later.addCallback(parse_json) 
response_object_later = response_dict_later.addCallback(construct_object) 
return response_object_later.addCallback(lambda response_object: 
             response_object.method()) 

Chiedendo perché non è possibile il fuoco (o "chiamata ") il Deferred restituito da make_request_async è simile a chiedere perché non si può avere make_requestrestituire più volte per causare la richiesta di essere riemessa. Se si desidera inviare nuovamente la richiesta nella versione sincrona, è necessario chiamare nuovamente make_request (e ottenere un nuovo risultato). Se si desidera inviare nuovamente la richiesta nella versione asincrona, è necessario chiamare nuovamente make_request_async (e ottenere un nuovo Deferred).