Come mantenere forzatamente un processo Node.js dalla chiusura?

TL; DR

Qual è il modo migliore per mantenere forzatamente un processo Node.js in esecuzione, vale a dire, impedire che il ciclo degli eventi si svuoti e quindi interrompere il processo? La soluzione migliore che ho potuto inventare era questa:

const SOME_HUGE_INTERVAL = 1 < {}, SOME_HUGE_INTERVAL); 

Che manterrà un intervallo in esecuzione senza causare troppi disturbi se si mantiene il periodo di intervallo abbastanza lungo.

C’è un modo migliore per farlo?

Versione lunga della domanda

Ho uno script Node.js che utilizza Edge.js per registrare una funzione di callback in modo che possa essere richiamata da una DLL in .NET. Questa funzione verrà chiamata 1 volta al secondo, inviando un numero di sequenza semplice che deve essere stampato sulla console.

La parte Edge.js va bene, tutto funziona. Il mio unico problema è che il mio processo Node.js esegue il suo script e dopo di esso esaurisce gli eventi da elaborare. Con il suo ciclo di eventi vuoto, termina semplicemente, ignorando il fatto che avrebbe dovuto continuare a essere in esecuzione per poter ricevere i callback dalla DLL.

    Il mio 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); 

    Il mio codice C # (la DLL):

     public class MyClass { Func<object, Task> Callback; void Bar() { int sequence = 1; while (true) { Callback(sequence++); Thread.Sleep(1000); } } public async Task Foo(dynamic input) { // Receives the callback function that will be used: Callback = (Func<object, Task>)input.callback; // Starts a new thread that will call back periodically: (new Thread(Bar)).Start(); return new object { }; } } 

    L’unica soluzione che ho trovato è stata la registrazione di un timer con un intervallo lungo per chiamare una funzione vuota solo per mantenere occupato lo scheduler ed evitare di ottenere il ciclo degli eventi vuoto in modo che il processo continuasse a funzionare per sempre.

    C’è un modo per farlo meglio di quello che ho fatto? Vale a dire, mantenere il processo in esecuzione senza dover utilizzare questo tipo di “hack”?

    Usa la modalità “vecchio” Stream per ascoltare un input standard che non arriverà mai:

     // Start reading from stdin so we don't exit. process.stdin.resume(); 

    Anche se sembra che non ci sia una risposta giusta a questa domanda, finora abbiamo 3 possibili hack e onestamente penso che il mio approccio sia meno intrusivo:

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

    Questo imposterà un intervallo che si accenderà all'incirca una volta ogni 12 giorni.

    Originariamente, il mio hack ha passato Number.POSITIVE_INFINITY come periodo, quindi il timer non sarebbe mai stato Number.POSITIVE_INFINITY , ma questo comportamento è stato modificato di recente e ora l'API non accetta nulla più grande di 2147483647 (cioè 2 ** 31 - 1 ). Vedi i documenti qui e qui .

    Per riferimento, ecco le altre due risposte fornite finora:

    Di Joe:

     require('net').createServer().listen(); 

    Creerà un "ascoltatore fasullo", come lo ha chiamato. Uno svantaggio minore è che dovremmo assegnare una porta solo per quello.

    Giacobbe:

     process.stdin.resume(); 

    O l'equivalente:

     process.stdin.on("data", () => {}); 

    Mette lo stdin in modalità "vecchia", una caratteristica deprecata che è ancora presente in Node.js per compatibilità con script scritti prima di Node.js v0.10 ( riferimento ).