Tarea de espera por x cantidad de tiempo e informe de progreso

Question

Necesito un mejor diseño para la tarea para dormir que Thread.Sleep, estoy usando la clase Task.

En mi aplicación wpf ejecuto una Tarea, esta tarea ejecuta otras dos tareas, cada una de estas tareas primero inicia sesión y el sitio web de Internet, después de iniciar sesión necesitan esperar unos segundos e informar al usuario cuándo procederán más lejos y este es mi problema, porque con Thread.Sleep no puedo informar el progreso.

Existen más funciones que el inicio de sesión, aproximadamente 5-6, todas solicitan un recurso de Internet, y entre ellas debe haber un tiempo de espera con el informe de tiempo restante enviar hacer gui, esta función de 5-6 son todas en una tarea, pero podría haber muchas tareas.

Lo que necesito es hacer que la tarea espere, pero también le permite enviar actualizaciones sobre el tiempo restante para proceder a la GUI.

¿Tiene alguna idea para este problema, cómo mejorarla, tal vez ya tenga algunos patrones de diseño para tal problema?

He oído también que el uso de Thread.Sleep es una práctica de diseño deficiente.

EDITAR: Nadie lo sabe? ¿Qué pasa con algún tipo de temporizador autónomo con espera de hilo como waithandle, autoresetevent, anyone?

Answer 1

Olvídate de utilizar Thread.Sleep. En su lugar, ejecute su tarea en un hilo de fondo y use un WaitHandle con un AutoResetEvent. (Enlaces: WaitHandle/WaitOne/AutoReset)

Su subproceso en segundo plano puede enviar actualizaciones de la interfaz de usuario con los delegados asincrónicos, pero el subproceso de llamada esperará hasta que sea lo que sucede:

1) Los informes de hilo que ha completado su tarea, usando yourwaithandle.Set();

o

2) los tiempos de espera de hilo de espera (tiempo de espera se establece como parámetro para WaitOne() -method).

Answer 2

En lugar de tener una sola tarea para realizar todas esas media docena de funciones (inicio de sesión, etc.), haga que cada función sea una tarea separada. A continuación, puede crear una cola de prioridad, ordenada por tiempo. Cuando desee iniciar una de estas meta-tareas, coloque su primera función en una cola junto con los datos de estado (es decir, URL, ID de usuario, contraseña, etc.).

A medida que se completa cada función, pone en cola la siguiente función que se realizará. Así que si las dos primeras funciones se registren y se get_data, tendría que:

queue login with state data to execute at DateTime.Now 
When login is finished, it queues get_data with the state data and DateTime.Now + 5 seconds (or whatever time) 

Cuando la última función se ejecuta, publica los resultados en alguna parte.

Puede configurar un temporizador que sondeará la cola 10 veces por segundo (o la próxima vez que se actualice el temporizador cada vez que se agregue algo a la cola). Puede comenzar tareas individuales según sea necesario.

El nuevo CTP Async puede tener ya este tipo de cosas: una "tarea de ejecución en el momento". Puede valer la pena investigarlo.

En cuanto al informe del progreso, cada función puede informar el progreso cuando se inicia (es decir, "iniciar sesión" ... "esperar 5 segundos para obtener datos" ... "obtener datos", etc.) Si lo desea, puede hacer que el hilo del temporizador recorra la cola de prioridad periódicamente e informe cuándo se ejecutarán determinadas tareas. Aunque eso podría ser excesivo.

Y lo que escuchó es correcto: Thread.Sleep es una idea excepcionalmente mala, especialmente cuando se trabaja con subprocesos de grupo de subprocesos.

Answer 3

La solución es tratarlo como una devolución de llamada asíncrona, en lugar de una espera síncrona. Si usted está en la asíncrono CTP, de la manera correcta sería:

async item => { await Task.Delay(1000); Process(item); }

Esto también parece ser un caso de uso ideal para DataFlow o Rx.

Uso de extensiones reactivas:

static void Track(int timeout, int frequency, string item) 
    { 
     Observable.Interval(TimeSpan.FromSeconds(frequency)) //produces 0, 1, 2.. with the interval 
        .Do(i => Console.WriteLine("Working on {0}", item)) // work on item 
        .TakeUntil(Observable.Timer(TimeSpan.FromSeconds(timeout))) //stop once the timer publishes a value 
        .Subscribe 
        (
         i => Console.WriteLine("Reporting {0}%", ((double)(i + 1)/timeout * 100)), // the interval reaches OnNext 
         e => Console.WriteLine("Error!"), // error occured 
         () => Console.WriteLine("Completed") // observable completed 
       ); 
    } 

en llamar a esto con Track(timeout: 5, frequency: 1, item: "http://example.com/?"), la salida producida es:

Working on http://example.com/? 
Reporting 20% 
Working on http://example.com/? 
Reporting 40% 
Working on http://example.com/? 
Reporting 60% 
Working on http://example.com/? 
Reporting 80% 
Completed 

Answer 4

Ha considerado el uso de un temporizador (de System.Timers) para realizar el intersticial " tiempo restante "¿actualizaciones de mensajes? Cada una de sus tareas podría establecer un tiempo esperado para el valor de finalización, luego su tarea de temporizador podría ser responsable de contar y actualizar la interfaz de usuario según sea necesario. No Thread.Sleep required, y Timer ejecutará su código Tick en un hilo del grupo de subprocesos.