Solución:
No estoy del todo seguro de qué tipo de sintaxis estás buscando, pero si no te gusta la sintaxis a en tu ejemplo, ¿por qué no usar Task ¿en lugar de?
Task.Run(() => doStuff("hello world"));
Realmente no parece mucho mejor, pero al menos no tiene un identificador sin usar.
Nota: Task.Run() es .Net 4.5 o posterior. Si está utilizando .Net 4, debe hacer:
Task.Factory.StartNew(() => doStuff("hello world"));
que no es tan corto.
Ambos de los anteriores usan el grupo de subprocesos.
Si realmente debe evitar usar una lambda, puede usar un delegado anónimo (que @nowhewhomustnotbenamed ya mencionó):
Task.Run(delegate { doStuff("Hello, World!"); });
¿Pero cuál es el punto de eso? ¡Es mucho menos legible!
La respuesta a su pregunta depende de cómo diseñe la aplicación. ¿Lo pones dentro de un proyecto común? no desea sobrecargar operaciones simples.
Pero, podría crear una llamada genérica para ThreadPool QueueUserItem que reciba parámetros, 1 parámetro, 2 parámetros, etc. Esto es bueno en lugar de enviar una cadena simple y estar restringido.
Así es como implica un parámetro QueueUserItem con WaitCallback:
ThreadPool.QueueUserWorkItem(
new WaitCallback(delegate(object state)
{ YourMethod(Param1, Param2, Param3); }), null);
tomado del método de ejecución C # (con parámetros) con ThreadPool
Y algunos enlaces para ideas:
http://msdn.microsoft.com/en-us/library/4yd16hza.aspx
ThreadPool genérico en .NET
Diferencia entre delegate.BeginInvoke y el uso de subprocesos ThreadPool en C #
¿Qué pasa con esto?
class Program
{
static void Main(string[] args)
{
ThreadPool.QueueUserWorkItem(MyWork, "text");
Console.ReadKey();
}
private static void MyWork(object argument)
{
Console.WriteLine("Argument: " + argument);
}
}
O si no desea restringir la firma y tiene una forma simple de poner métodos en un hilo, puede hacerlo así: para los métodos que devuelven un valor y no devuelven un valor y tienen hasta 6 parámetros, sería necesario que defina 12 sobrecargas si no me equivoco. Requiere un poco más de trabajo por adelantado, pero es más fácil de usar.
class Program
{
static void Main(string[] args)
{
var myClass = new MyClass();
myClass.DoWork();
Console.ReadKey();
}
}
public static class ObjectThreadExtension
{
public static void OnThread(this object @object, Action action)
{
ThreadPool.QueueUserWorkItem(state =>
{
action();
});
}
public static void OnThread<T>(this object @object, Action<T> action, T argument)
{
ThreadPool.QueueUserWorkItem(state =>
{
action(argument);
});
}
}
public class MyClass
{
private void MyMethod()
{
Console.WriteLine("I could have been put on a thread if you like.");
}
private void MySecondMethod(string argument)
{
Console.WriteLine(argument);
}
public void DoWork()
{
this.OnThread(MyMethod);
this.OnThread(MySecondMethod, "My argument");
}
}