Enhebrado y expresiones lambda

Question

¿Cuál es la diferencia entre los dos códigos siguientes? ¿Habrá algún problema usando el segundo?

Escenario 1:

private void Log(Exception e) 
{ 
    ThreadPool.QueueUserWorkItem(new WaitCallback(Log), e); 
} 

private void Log(object obj) 
{ 
    Exception e = (Exception)obj; 
    Logger.Log(e); 
} 

Escenario 2

private void Log(Exception e) 
{ 
    ThreadPool.QueueUserWorkItem(
     (obj) => 
      { 
       Logger.Log(e); 
      }); 
} 

En el escenario 2, no estoy pasando la excepción como un parametro a la ThreadPool. ¿Cómo se produce la distribución de subprocesos del objeto de excepción? ¿Habrá algún problema? ¿Cuáles son las limitaciones de hacer esto si es que hay alguno? La gran ventaja es que puede pasar cualquier número de parámetros muy fácilmente.

Answer 1

La única diferencia es que en el escenario dos está cerrando la variable e que mueve efectivamente la variable de pila e a un tipo personalizado que se mueve al montón para que no lo pierda.

Creo que esto debería funcionar bien.

Edit: En cuanto al rendimiento, no debería haber una diferencia significativa entre los dos escenarios. En el escenario 1 ya está pasando la excepción como state al método QueueUserWorkItem que mueve internamente esa referencia de excepción al montón. La única sobrecarga es que cuando usa un cierre es que el compilador crea un tipo para usted y almacena las variables capturadas como campos de ese tipo.

Answer 2

para notar, en lugar de la Lambda, se podría hacer lo mismo con un método anónimo, y también funcionaría en C# 2.0:

ThreadPool.QueueUserWorkItem(delegate(Object e) 
    { 
     Logger.Log(e as Exception); 
    });