c# - ejemplo - ¿Cómo puedo obtener que esta aplicación de consola basada en eventos no finalice inmediatamente?

filesystemwatcher windows service c#

Question

Fuente

class Program
{
    static void Main(string[] args)
    {
        var fw = new FileSystemWatcher(@"M:/Videos/Unsorted");
        fw.Created+= fw_Created;
    }

    static void fw_Created(object sender, FileSystemEventArgs e)
    {
        Console.WriteLine("added file {0}", e.Name);
    }
}

Pregunta

Debería ser bastante auto explicativo. Intento crear un vigilante de archivos para que pueda ordenar mis videos automáticamente ... ¿cómo puedo lograr que el programa no termine nunca?

Quiero mantenerlo basado en la consola por ahora para poder depurarlo, pero eventualmente quiero eliminar la consola y simplemente ejecutarla en segundo plano (supongo que como un servicio).

Answer 1

He tenido exactamente el mismo problema que tú. Lo que hice es si el programa se lanza con la línea de comando --console le pedirá que --console enter para cerrar, si no hay parámetros, se espera que se lance como un servicio.

class MyExampleApp : ServiceBase
{

    public static void Main(string[] args)
    {
        if (args.Length == 1 && args[0].Equals("--console"))
        {
            new MyExampleApp().ConsoleRun();
        }
        else
        {
            ServiceBase.Run(new MyExampleApp());
        }
    }
    private void ConsoleRun()
    {
        Console.WriteLine(string.Format("{0}::starting...", GetType().FullName));

        OnStart(null);

        Console.WriteLine(string.Format("{0}::ready (ENTER to exit)", GetType().FullName));
        Console.ReadLine();

        OnStop();

        Console.WriteLine(string.Format("{0}::stopped", GetType().FullName));
    }
    //snip
}

Answer 2

Las aplicaciones de consola nunca son una buena forma de probar eventos debido a este escenario. Sea cual sea el método que utilice, tiene que detener el hilo actual, ya sea que duerma o bloquee algún ciclo while (verdadero), que evita que sus eventos se disparen o hace que sea casi imposible alcanzar los puntos de interrupción dentro de los eventos. Use una aplicación de Windows si puede.

Answer 3

Puedes esperar por siempre con esto:

System.Threading.Thread.Sleep(-1);

Answer 4

class Program
{
    static void Main(string[] args)
    {
        var fw = new FileSystemWatcher(@"M:/Videos/Unsorted");
        fw.EnableRaisingEvents = true;
        fw.Created += fw_Created;

        Console.ReadLine();

    }

    static void fw_Created(object sender, FileSystemEventArgs e)
    {
        Console.WriteLine("added file {0}", e.Name);
    }

}

Simplemente tenía que EnableRaisingEvents aparentemente.

Encontré otra solución que quizás sea aún mejor:

class Program
{
    static void Main(string[] args)
    {
        var fw = new FileSystemWatcher(@"M:/Videos/Unsorted");
        fw.Created += fw_Created;
        while(true) fw.WaitForChanged(WatcherChangeTypes.All);
    }

    static void fw_Created(object sender, FileSystemEventArgs e)
    {
        Console.WriteLine("added file {0}", e.Name);
    }
}

Answer 5

Quizás algo como esto:

class Program
{
    static void Main(string[] args)
    {
        var fw = new FileSystemWatcher(@"M:/Videos/Unsorted");
        fw.Changed += fw_Changed;
        fw.EnableRaisingEvents = true;

        new System.Threading.AutoResetEvent(false).WaitOne();
    }

    static void fw_Changed(object sender, FileSystemEventArgs e)
    {
        Console.WriteLine("added file {0}", e.Name);
    }
}

Actualizar

Con el ánimo de ayudar a cualquier otra persona que esté buscando una solución similar, como @Mark declaró en los comentarios, también hay una forma de usar el método WaitForChanged de la clase FileSystemWatcher para resolver esta pregunta:

class Program
{
    static void Main(string[] args)
    {
        var fw = new FileSystemWatcher(@".");
        while (true)
        {
            Console.WriteLine("added file {0}",
                fw.WaitForChanged(WatcherChangeTypes.All).Name);
        }
    }
}

Hacerlo permite que la aplicación espere indefinidamente (o hasta que se rompa el tiempo) para que se modifique un archivo.