Esistono le migliori pratiche per l'implementazione di un ciclo asincrono del motore di gioco?

Question

Ho implementato un ciclo motore di gioco come segue:

public static Boolean Start () 
{ 
    if (hasBoard) 
    { 
     // start engine on worker thread 
     asyncTask = new AsyncResult (stopEngine, asyncTask); 
     isRunning = ThreadPool.QueueUserWorkItem (startEngine, asyncTask); 

     if (isRunning) 
     { 
      Console.WriteLine ("[{0}] Engine started", 
       DateTime.Now.ToString ("hh:mm:ss")); 
     } 
     else 
     { 
      Console.WriteLine ("[{0}] Engine failed to start", 
       DateTime.Now.ToString ("hh:mm:ss")); 
     } 
    } 

    return isRunning; 
} 

public static void Stop () 
{ 
    Console.WriteLine ("[{0}] Engine stopping", 
     DateTime.Now.ToString ("hh:mm:ss")); 

    asyncTask.SetAsCompleted (null, false); 
} 

private static void startEngine (Object task) 
{ 
    while (!((IAsyncResult)task).IsCompleted) 
    { 
     Thread.Sleep (10000); 

     Console.WriteLine ("[{0}] Engine running", 
      DateTime.Now.ToString ("hh:mm:ss")); 
    } 
} 

private static void stopEngine (IAsyncResult iaResult) 
{ 
    // clean up resources 

    Console.WriteLine ("[{0}] Engine stopped", 
     DateTime.Now.ToString ("hh:mm:ss")); 

    isRunning = false; 
} 

Sto usando la classe AsyncResult consigliato da Jeff Richter nel suo articolo, Implementing the CLR Asynchronous Programming Model. Per essere in grado di fermare il motore dall'interfaccia utente, l'implementazione che ho utilizzato era un po 'diversa dallo schema asincrono standard. Questa implementazione funziona come previsto, ma quando mi allontano da una pratica standard, torno alla comunità SO per garantire che sto facendo le cose nel modo giusto.

Ci sono problemi con questa implementazione che chiunque può vedere?

Answer 1

Dato che suona come un progetto su cui hai il controllo, ti suggerirei di abbandonare APM e utilizzare il modello basato su Task fornito in .NET4. Questo è l'approccio consigliato per .NET4 anziché APM. La classe Task fa parte della Libreria parallela attività (TPL) ma è ottima anche per questi lavori asincroni di base.

private CancellationTokenSource cts; 

public void StartEngine() 
{ 
    if (cts == null) 
    { 
     cts = new CancellationTokenSource(); 
     Task.Factory.StartNew(() => GameLoop(cts.Token), cts.Token); 
    } 
} 

private void GameLoop(CancellationToken token) 
{ 
    while (true) 
    { 
     token.ThrowIfCancellationRequested(); 
     Thread.Sleep(1000); 
     Debug.WriteLine("working..."); 
    } 
} 

public void StopEngine() 
{ 
    if (cts != null) 
    { 
     cts.Cancel(); 
     cts = null; 
    } 
} 

Answer 2

Direi che è implicito che le attività sono di breve durata quando si utilizza il pool di thread poiché il numero di thread in esso è limitato.

Nel tuo caso utilizzerei un BackgroundWorker poiché hai menzionato le winform. BW gestisce la sincronizzazione per te e quindi è in grado di aggiornare la GUI senza utilizzare InvokeRequired ecc.