Valore di ritorno dalle attività padre-figlio

Question

Nel frammento di seguito, un'attività crea due attività figlio utilizzando TaskCreationOptions.AttachedToParent, il che significa che l'attività padre attenderà il completamento delle attività figlio.

La domanda è: perché l'attività padre non restituisce il valore corretto [102]? Determina innanzitutto il suo valore di ritorno e quindi attende che le attività figlio finiscano. Se è così, allora qual è il punto di creare una relazione genitore-figlio?

void Main() 
{ 
Console.WriteLine ("Main start."); 
int i = 100; 

Task<int> t1 = new Task<int>(()=> 
{ 
    Console.WriteLine ("In parent start"); 
    Task c1 = Task.Factory.StartNew(() => { 
     Thread.Sleep(1000); 
     Interlocked.Increment(ref i); 
     Console.WriteLine ("In child 1:" + i); 
    }, TaskCreationOptions.AttachedToParent); 

    Task c2 = Task.Factory.StartNew(() => { 
     Thread.Sleep(2000); 
     Interlocked.Increment(ref i);   
     Console.WriteLine ("In child 2:" + i); 
    }, TaskCreationOptions.AttachedToParent); 

    Console.WriteLine ("In parent end"); 
    return i; 
}); 

t1.Start(); 
Console.WriteLine ("Calling Result."); 
Console.WriteLine (t1.Result); 
Console.WriteLine ("Main end."); 
} 

L'output:

Main start. 
Calling Result. 
In parent start 
In parent end 
In child 1:101 
In child 2:102 
100 
Main end. 

Answer 1

Il problema è che si crea c1 e c2 come attività separate, ma poi torna subito i da t1 prima c1 e c2 hanno incrementato i.

Pertanto, il valore restituito da t1 viene catturato in quel punto ed è ancora 100.

Come hai notato, non c'è molto senso in una relazione genitore/figlio per questo accordo; ma ci sono un sacco di casi in cui è ha senso.

Un uso comune è giusto in modo che l'attività padre non venga completata fino a quando le sue attività figlio non sono state completate, ma se si richiede all'attività padre di attendere i propri figli prima di restituire un valore, non sarà possibile farlo come Questo.

Naturalmente, è possibile risolvere il problema con l'aggiunta di

Task.WaitAll(c1, c2); 

poco prima della return i;. So che non è quello che stai chiedendo, ma volevo solo farlo notare comunque.

Answer 2

Come già detto, il valore di i viene restituito prima che venga incrementato. cambiando il codice in questo modo restituire il valore atteso (102):

void Main() 
{ 
    Console.WriteLine ("Main start."); 
    int i = 100; 

    Task<int> t1 = new Task<int>(()=> 
    { 


    Console.WriteLine ("In parent start"); 
    Task c1 = Task.Factory.StartNew(() => { 
     Interlocked.Increment(ref i); 
     Console.WriteLine ("In child 1:" + i); 
    }, TaskCreationOptions.AttachedToParent); 

    Thread.Sleep(1000); 

    Task c2 = Task.Factory.StartNew(() => { 
     Interlocked.Increment(ref i);   
     Console.WriteLine ("In child 2:" + i); 
    }, TaskCreationOptions.AttachedToParent); 

    Thread.Sleep(1000); 

    Console.WriteLine ("In parent end"); 
    return i; 
}); 

t1.Start(); 
Console.WriteLine ("Calling Result."); 
Console.WriteLine (t1.Result); 
Console.WriteLine ("Main end."); 
} 

quello che ho fatto è semplicemente estrarre il Thread.Sleep (1000) dal compito bambino per l'attività principale. Il risultato viene restituito ora dopo che la variabile è stata incrementata.