example - C#- ThreadPool QueueUserWorkItem Use?

threadpool queueuserworkitem example

Question

Ahora mismo estoy usando el siguiente código para agregar hilos en cola. No me gusta Y mis colegas tampoco lo harán porque no conocen muy bien C #. Todo lo que quiero es, por supuesto, poner en cola un método para ser ejecutado en un nuevo hilo.

private static void doStuff(string parameter)
{
    // does stuff
}

// call (a)
ThreadPool.QueueUserWorkItem(a => doStuff("hello world"));
// call (b)
ThreadPool.QueueUserWorkItem(delegate { doStuff("hello world"); });

Entonces, ¿hay otras variaciones de uso de ThreadPool.QueueUserWorkItem ?

Mejor sería otra 1-Line-Call. Si es posible con el uso de Func<> o Action<> .

EDIT: Obtuve (b) de las respuestas y los comentarios y ya me gusta más.

Answer 1

La respuesta a su pregunta depende de cómo diseñe la aplicación. ¿Lo pones dentro de un proyecto común? Usted no quiere sobrecargar las operaciones simples.

Sin embargo, puede crear una llamada genérica para ThreadPool QueueUserItem que recibe params, 1 param, 2 param, etc. Esto es bueno en lugar de enviar una cadena simple y restringirse.

Así es como se implementa un parámetro QueueUserItem con WaitCallback:

ThreadPool.QueueUserWorkItem(
  new WaitCallback(delegate(object state)
  { YourMethod(Param1, Param2, Param3); }), null);

tomado de C # Ejecutar método (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 #

Answer 2

No estoy completamente seguro de qué tipo de sintaxis está buscando, pero si no le gusta la no utilizada en su ejemplo, ¿por qué no usar Task lugar?

Task.Run(() => doStuff("hello world"));

Realmente no parece mucho mejor, pero al menos no tiene un identificador no utilizado.

Nota: Task.Run() es .Net 4.5 o posterior. Si estás usando .Net 4 tienes que hacer:

Task.Factory.StartNew(() => doStuff("hello world"));

que no es tan corto

Ambos de los anteriores utilizan el grupo de subprocesos.

Si realmente debes evitar usar un lambda, puedes usar un delegado anónimo (que @nowhewhomustnotbenamed ya mencionado):

Task.Run(delegate { doStuff("Hello, World!"); });

Pero ¿cuál es el punto de eso? ¡Es mucho menos legible!

Answer 3

Que hay de 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 que la firma sea restrictiva y tiene una forma sencilla de poner métodos en un hilo, puede hacerlo de esta manera. Para los métodos que hacen y no devuelven un valor y tienen hasta 6 parámetros, es necesario que los 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");
    }
}