using System;
using System.Threading;

namespace Recetas.CSharp.Cap04.R0408
{
    public sealed class RecetaEventWaitHandle
    {
        // Valor centinela para notificar cuando el 
        // segundo thread debe terminar:
        private static bool terminar = false;
        
        // Método utilitario para la presentación de información 
        // del estado de ejecución:
        private static void Rastreo(string mensaje)
        {
            Console.WriteLine ("[{0,3}] - {1} : {2}", 
                Thread.CurrentThread.ManagedThreadId, 
                DateTime.Now.ToString("HH:mm:ss.ffff"), 
                mensaje
            );
        }
        
        // Método que se ejecutará en un thread nuevo. Este método 
        // espera a que un objeto EventWaitHandle genera una señal antes 
        // de mostrar un mensaje en la salida estándar:
        private static void MostrarMensaje ()
        {
            // Captura un objeto EventWaitHandle con la invocación 
            // del método OpenExisting:
            EventWaitHandle evento = EventWaitHandle.OpenExisting ("EventoEjemplo");
            
            Rastreo ("El método `MostrarMensaje` se ha iniciado.");
            
            while (!terminar)
            {
                // Sobre el objeto EventWaitHandle se hace una espera de 2 segundos 
                // y mientras que no se notifique al objeto EventWaitHandle 
                // el valor de retorno de WaitOne será false:
                if (evento.WaitOne (2000, true))
                {
                    Rastreo ("EventWaitHandle en estado notificado.");
                }
                else
                {
                    Rastreo ("EventWaitHandle en estado no-notificado.");
                }
                
                // Espera de dos segundos:
                Thread.Sleep (2000);
            }
            Rastreo ("El thread está a punto de terminar.");
        }
        
        public static void Main()
        {
            // Creación de instancia de EventWaitHandle:
            using (EventWaitHandle evento = 
                   new EventWaitHandle (true, EventResetMode.ManualReset, "EventoEjemplo"))
            {
                // Creación de un thread:
                Rastreo ("Iniciando un nuevo thread.");
                Thread t = new Thread (MostrarMensaje);
                t.Start ();
                
                // Facilita alternar entre los estados signaled y unsignaled 
                // a la instancia EventWaitHandle:
                for (int i = 0; i < 3; ++i)
                {
                    Console.WriteLine ("\nPresione la tecla Enter...");
                    Console.ReadLine ();
                    
                    // Para conocer el estado del objeto EventWaitHandle, es 
                    // necesario invocar al método WaitOne con 0 segundos 
                    // de retraso:
                    if (evento.WaitOne (0, true))
                    {
                        Rastreo ("Pasando el evento a estado no-señalado (unsignaled).");
                        
                        // El evento (EventWaitHandle) es notificado:
                        evento.Reset();
                    }
                    else
                    {
                        Rastreo ("Pasando el evento a estado señalado (signaled).");
                        
                        evento.Set();
                    }
                }
                
                // Finalizamos la ejecución del método MostrarMensaje:
                terminar = true;
                // Permitimos su ejecución:
                evento.Set();
                // Esperamos a que terminen todos los threads:
                t.Join (5000);
            }
            
            Console.WriteLine ("\nEl thread Main ha terminado. Presione Enter");
            Console.ReadLine ();
            
            
        }
    }
}