Pourquoi la fenêtre de la console se ferme-t-elle immédiatement une fois la sortie affichée?

J’étudie C # en suivant les guides de MSDN .

Maintenant, j’ai juste essayé l’ exemple 1 ( voici le lien vers MSDN ), et j’ai rencontré un problème: pourquoi la fenêtre de la console se ferme-t-elle immédiatement une fois que j’ai affiché mes résultats?

using System; public class Hello1 { public static int Main() { Console.WriteLine("Hello, World!"); return 0; } } 

    le problème ici est que leur programme Hello World apparaît alors il se fermerait immédiatement.
    pourquoi donc?

    Parce que c’est fini. Lorsque les applications de la console ont terminé leur exécution et qu’elles reviennent de leur méthode main , la fenêtre de la console associée se ferme automatiquement. Ceci est le comportement attendu.

    Si vous souhaitez le garder ouvert à des fins de débogage, vous devez demander à l’ordinateur d’attendre un appui sur la touche avant de terminer l’application et de fermer la fenêtre.

    La méthode Console.ReadLine est une façon de procéder. L’ajout de cette ligne à la fin de votre code (juste avant la déclaration de return ) provoquera l’attente de l’application pour appuyer sur une touche avant de quitter.

    Alternativement, vous pouvez démarrer l’application sans le débogueur attaché en appuyant sur Ctrl + F5 depuis l’environnement Visual Studio, mais cela présente l’inconvénient évident de vous empêcher d’utiliser les fonctionnalités de débogage, que vous souhaiterez probablement lors de l’écriture d’une application.

    Le meilleur compromis consiste probablement à appeler la méthode Console.ReadLine uniquement lors du débogage de l’application en l’encapsulant dans une directive de préprocesseur. Quelque chose comme:

     #if DEBUG Console.WriteLine("Press enter to close..."); Console.ReadLine(); #endif 

    Vous pouvez également souhaiter que la fenêtre rest ouverte si une exception non interceptée a été lancée. Pour ce faire, vous pouvez mettre la Console.ReadLine(); dans un bloc finally :

     #if DEBUG try { //... } finally { Console.WriteLine("Press enter to close..."); Console.ReadLine(); } #endif 

    À la place d’utiliser

     Console.Readline() Console.Read() Console.ReadKey() 

    vous pouvez exécuter votre programme en utilisant Ctrl + F5 (si vous êtes dans Visual Studio). Ensuite, Visual Studio maintiendra la fenêtre de la console ouverte jusqu’à ce que vous appuyiez sur une touche.

    Remarque: vous ne pouvez pas déboguer votre code dans cette approche.

    Cela se comporte de la même façon pour Ctrl F5 ou F5 . Placez immédiatement avant la fin de Main méthode Main .

     using System.Diagnostics; private static void Main(ssortingng[] args) { DoWork(); if (Debugger.IsAttached) { Console.WriteLine("Press any key to continue . . ."); Console.ReadLine(); } } 

    Le programme se ferme immédiatement car rien ne l’empêche de se fermer. Insérer un point d’arrêt au return 0; ou ajoutez Console.Read(); avant return 0; pour empêcher la fermeture du programme.

    Je suppose que la raison pour laquelle vous ne voulez pas la fermer en mode Debug est que vous voulez regarder les valeurs des variables, etc. Il est donc préférable d’insérer un point d’arrêt sur la fermeture “}” de la fonction principale . Si vous n’avez pas besoin de déboguer, alors Ctrl-F5 est la meilleure option.

    Alternativement, vous pouvez retarder la fermeture en utilisant le code suivant:

     System.Threading.Thread.Sleep(1000); 

    Notez que le mode Sleep utilise des millisecondes.

    Une autre méthode consiste à utiliser Debugger.Break() avant de revenir de la méthode Main

    Le code est terminé, pour continuer vous devez append ceci:

     Console.ReadLine(); 

    ou

     Console.Read(); 

    Utilisez Console.Read (); pour empêcher le programme de se fermer, mais assurez-vous d’append Console.Read(); code avant déclaration de retour, sinon ce sera un code inaccessible.

      Console.Read(); return 0; 

    vérifier cette console.Lire

    Ajouter La méthode Read pour afficher la sortie.

     Console.WriteLine("Hello, World!"); Console.Read(); return 0; 

    Le programme se ferme dès que son exécution est terminée. Dans ce cas, lorsque vous return 0; . Ceci est la fonctionnalité attendue. Si vous voulez voir la sortie, exécutez-la manuellement dans un terminal ou attendez à la fin du programme pour qu’elle rest ouverte pendant quelques secondes (en utilisant la bibliothèque de threads).

    Si vous voulez garder l’application ouverte, vous ne pouvez rien faire qui maintienne le processus en vie, alors regardez le code ci-dessous:

     while (true); 

    C’est le moyen le plus simple de réaliser le comportement attendu, mais il fuit le processeur, qui est forcé d’itérer à l’infini.

    À ce stade, vous pouvez choisir d’utiliser System.Windows.Forms.Application (mais il faut append la référence System.Windows.Forms ):

     Application.Run(); 

    Cela ne fuit pas le processeur et fonctionne correctement.

    Pour éviter d’append la référence System.Windows.Forms vous pouvez utiliser une astuce simple, en important System.Threading :

     SpinWait.SpinUntil(() => false); 

    Cela fonctionne également parfaitement, et consiste mentalement en un iterator while avec une condition de négation renvoyée par la méthode lambda ci-dessus. Mais ça ne fuit pas de CPU! Pourquoi? Vous pouvez regarder le code source ici , mais il tourne essentiellement attend le thread en cours.

    Vous pouvez également opter pour la création d’un boucleur de messages qui examine les messages en attente et les traite avant de passer à l’itération suivante:

     [DebuggerHidden, DebuggerStepperBoundary, DebuggerNonUserCode, DllImport("user32.dll", EntryPoint = "PeekMessage")] public static extern int PeekMessage(out NativeMessage lpMsg, IntPtr hWnd, int wMsgFilterMin, int wMsgFilterMax, int wRemoveMsg); [DebuggerHidden, DebuggerStepperBoundary, DebuggerNonUserCode, DllImport("user32.dll", EntryPoint = "GetMessage")] public static extern int GetMessage(out NativeMessage lpMsg, IntPtr hWnd, int wMsgFilterMin, int wMsgFilterMax); [DebuggerHidden, DebuggerStepperBoundary, DebuggerNonUserCode, DllImport("user32.dll", EntryPoint = "TranslateMessage")] public static extern int TranslateMessage(ref NativeMessage lpMsg); [DebuggerHidden, DebuggerStepperBoundary, DebuggerNonUserCode, DllImport("user32.dll", EntryPoint = "DispatchMessage")] public static extern int DispatchMessage(ref NativeMessage lpMsg); [DebuggerHidden, DebuggerStepperBoundary, DebuggerNonUserCode] public static bool ProcessMessageOnce() { NativeMessage message = new NativeMessage(); if (!IsMessagePending(out message)) return true; if (GetMessage(out message, IntPtr.Zero, 0, 0) == -1) return true; Message frameworkMessage = new Message() { HWnd = message.handle, LParam = message.lParam, WParam = message.wParam, Msg = (int)message.msg }; if (Application.FilterMessage(ref frameworkMessage)) return true; TranslateMessage(ref message); DispatchMessage(ref message); return false; } 

    Ensuite, vous pouvez faire une boucle en toute sécurité en faisant quelque chose comme ceci:

     while (true) ProcessMessageOnce(); 

    Vous pouvez également le faire mieux en remplaçant l’iterator while par une invocation SpinWait.SpinUntil :

     SpinWait.SpinUntil(ProcessMessageOnce); 

    Ajoutez ce qui suit avant le retour 0:

     system("PAUSE"); 

    Cela imprime une ligne pour bash une clé pour fermer la fenêtre. Il gardera la fenêtre jusqu’à ce que vous appuyiez sur la touche Entrée. Je demande à mes élèves de l’append à tous leurs programmes.

    Si votre programme exige que vous appuyiez sur Entrée pour continuer comme si vous deviez entrer une valeur et continuer, ajoutez un nouveau double ou un int et tapez write avant le retour à zéro (0); scanf_s (“% lf”, & la variable);

    J’ajoute toujours l’instruction suivante à une application de console (créez un extrait de code pour cela si vous le souhaitez).

     Console.WriteLine("Press any key to quit!"); Console.ReadKey(); 

    Cela aide lorsque vous souhaitez expérimenter différents concepts via l’application console.

    Ctr + F5 fera que la console rest mais vous ne pouvez pas déboguer! Toutes les applications de console que j’ai écrites dans realworld sont toujours non interactives et déclenchées par un planificateur tel que TWS ou CA Work Station et n’ont pas besoin de quelque chose comme ceci.

    Pour simplifier ce que les autres disent: Utilisez Console.ReadKey(); .

    Cela fait que le programme attend que l’utilisateur appuie sur une touche normale du clavier

    Source: Je l’utilise dans mes programmes pour les applications console.

    Vous pouvez résoudre ce problème très simplement en invoquant l’entrée. Cependant, si vous appuyez sur Enter la console disparaîtra à nouveau. Utilisez simplement cette Console.ReadLine(); ou Console.Read();

    Selon mon souci, si nous voulons stabiliser l’APPLICATION OUTPUT OF CONSOLE, jusqu’à la fin de l’affichage de sortie USE, l’étiquette: après MainMethod, et goto label; avant la fin du programme

    Dans le programme.

    par exemple:

     static void Main(ssortingng[] args) { label: ---------- *****snippet of code***** ----------- **goto label;** }