TL; DR

¿Cuál es la mejor manera de mantener a la fuerza un proceso Node.js en ejecución, es decir, evitar que su ciclo de eventos se ejecute vacío y, por lo tanto, evitar que el proceso finalice? La mejor solución que pude encontrar fue esta:

const SOME_HUGE_INTERVAL = 1 << 30;
setInterval(() => {}, SOME_HUGE_INTERVAL);

Lo que mantendrá un intervalo en ejecución sin causar demasiadas molestias si mantiene el período de intervalo lo suficiente.

Hay una mejor manera de hacerlo?

Versión larga de la pregunta.

Tengo un script Node.js usandoEdge.js para registrar una función de devolución de llamada para poder llamarla desde dentro de una DLL en .NET. Esta función se llamará 1 vez por segundo, enviando un número de secuencia simple que debe imprimirse en la consola.

La parte de Edge.js está bien, todo está funcionando. Mi único problema es que mi proceso Node.js ejecuta su script y luego se queda sin eventos para procesar. Con su bucle de eventos vacío, simplemente termina, ignorando el hecho de que debería haber seguido ejecutándose para poder recibir devoluciones de llamada de la DLL.

Mi script Node.js:

var
    edge = require('edge');

var foo = edge.func({
    assemblyFile: 'cs.dll',
    typeName: 'cs.MyClass',
    methodName: 'Foo'
});

// The callback function that will be called from C# code:
function callback(sequence) {
    console.info('Sequence:', sequence);
}

// Register for a callback:
foo({ callback: callback }, true);

// My hack to keep the process alive:
setInterval(function() {}, 60000);

Mi código C # (la DLL):

public class MyClass
{
    Func<object, Task<object>> Callback;

    void Bar()
    {
        int sequence = 1;

        while (true)
        {
            Callback(sequence++);
            Thread.Sleep(1000);
        }
    }

    public async Task<object> Foo(dynamic input)
    {
        // Receives the callback function that will be used:
        Callback = (Func<object, Task<object>>)input.callback;

        // Starts a new thread that will call back periodically:
        (new Thread(Bar)).Start();

        return new object { };
    }
}

La única solución que se me ocurrió fue registrar un temporizador con un intervalo largo para llamar a una función vacía solo para mantener ocupado el planificador y evitar que el bucle de eventos esté vacío para que el proceso siga ejecutándose para siempre.

¿Hay alguna manera de hacerlo mejor que yo? Es decir, mantener el proceso en ejecuciónsin tener que usar este tipo de "pirateo"?