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

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

Maintenant, je viens d'essayer 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 ma sortie affichée?

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, puis il se fermera immédiatement.
pourquoi donc?

Parce que c'est fini. Lorsque les applications de la console ont terminé l'exécution et retournent de leur mainméthode, la fenêtre de la console associée se ferme automatiquement. Il s'agit d'un comportement attendu.

Si vous souhaitez le garder ouvert à des fins de débogage, vous devrez demander à l'ordinateur d'attendre une pression sur une touche avant de mettre fin à l'application et de fermer la fenêtre.

La Console.ReadLineméthode est une façon de faire cela. Si vous ajoutez cette ligne à la fin de votre code (juste avant l' returninstruction), l'application attendra que vous appuyiez sur une touche avant de quitter.

Vous pouvez également démarrer l'application sans le débogueur attaché en appuyant sur Ctrl+ à F5partir de 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 souhaitez probablement à votre disposition lors de l'écriture d'une application.

Le meilleur compromis est probablement d'appeler la Console.ReadLineméthode uniquement lors du débogage de l'application en l'enveloppant 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 reste ouverte si une exception non interceptée a été levée. Pour ce faire, vous pouvez mettre le Console.ReadLine();dans un finallybloc:

#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 gardera 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.

Je suppose que la raison pour laquelle vous ne voulez pas qu'il se ferme en mode Débogage, c'est parce que vous voulez regarder les valeurs des variables etc. Il est donc probablement préférable d'insérer simplement 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.

Cela se comporte de la même manière pour CtrlF5ou F5. Placer immédiatement avant la fin de la Mainméthode.

using System.Diagnostics;

private static void Main(string[] 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érez un point d'arrêt à return 0;ou ajoutez Console.Read();avant return 0;pour empêcher le programme de se fermer.

Je suis un peu en retard à la fête, mais: dans Visual Studio 2019 pour les projets .NET Core, la console ne se ferme pas automatiquement par défaut. Vous pouvez configurer le comportement via le menu Outils → Options → Débogage → Général → Fermer automatiquement la console lorsque le débogage s'arrête. Si vous obtenez la fermeture automatique de la fenêtre de votre console, vérifiez si le paramètre mentionné n'est pas défini.

La même chose s'applique aux projets de console de nouveau style .NET Framework:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net472</TargetFramework>
  </PropertyGroup>

</Project>

L'ancien projet .NET Framework ferme toujours inconditionnellement la console à la fin (à partir de Visual Studio 16.0.1).

Référence: https://devblogs.microsoft.com/dotnet/net-core-tooling-update-for-visual-studio-2019-preview-2/

Si vous souhaitez garder votre application ouverte, vous devez faire quelque chose pour maintenir son processus en vie. L'exemple ci-dessous est le plus simple, à mettre à la fin de votre programme:

while (true) ;

Cependant, cela entraînera une surcharge du processeur, car il est donc obligé d'itérer à l'infini.

À ce stade, vous pouvez choisir d'utiliser la System.Windows.Forms.Applicationclasse (mais cela vous oblige à ajouter une System.Windows.Formsréférence):

Application.Run();

Cela ne fuit pas le processeur et fonctionne avec succès.

Afin d'éviter d'ajouter une System.Windows.Formsréférence, vous pouvez utiliser une astuce simple, la soi-disant attente de rotation , en important System.Threading:

SpinWait.SpinUntil(() => false);

Cela fonctionne également parfaitement et consiste essentiellement en une whileboucle avec une condition négative renvoyée par la méthode lambda ci-dessus. Pourquoi ce processeur ne surcharge-t-il pas? Vous pouvez consulter le code source ici ; Quoi qu'il en soit, il attend essentiellement un cycle du processeur avant de recommencer.

Vous pouvez également créer un boucleur de messages, qui examine les messages en attente du système et traite chacun d'eux avant de passer à l'itération suivante, comme suit:

[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 boucler en toute sécurité en faisant quelque chose comme ceci:

while (true)
    ProcessMessageOnce();

Vous pouvez également retarder la fermeture à l'aide du code suivant:

System.Threading.Thread.Sleep(1000);

Notez que le Sleeputilise des millisecondes.

Une autre façon est d'utiliser Debugger.Break()avant de revenir de la méthode Main

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

Console.ReadLine();

ou

Console.Read();

Utilisez Console.Read (); pour empêcher le programme de se fermer, mais assurez-vous d'ajouter le Console.Read();code avant l'instruction return, sinon ce sera un code inaccessible.

    Console.Read(); 
    return 0; 

vérifiez cette console.

Add La Readméthode pour afficher la sortie.

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

Voici une façon de le faire sans impliquer Console:

var endlessTask = new TaskCompletionSource<bool>().Task;
endlessTask.Wait();

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

c'est la réponse asynchrone à l'application console en C #?

n'importe où dans l'application console, n'utilisez jamais awaitmais utilisez plutôt theAsyncMethod().GetAwaiter().GetResult();,

exemple

var result = await HttpClientInstance.SendAsync(message);

devient

var result = HttpClientInstance.SendAsync(message).GetAwaiter().GetResult();

si votre programme vous oblige à appuyer sur Entrée pour continuer comme vous devez entrer une valeur et continuer, ajoutez un nouveau double ou int et tapez write avant retunr (0); scanf_s ("% lf", & la variable);

J'ajoute toujours l'instruction suivante à une application 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 une application console.

Ctr + F5 fera rester la console mais vous ne pouvez pas déboguer! Toutes les applications 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 ne nécessitent pas quelque chose comme ça.

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

Cela permet au programme d'attendre que l'utilisateur appuie sur une touche normale du clavier

Source: je l'utilise dans mes programmes pour les applications console.

Vous pouvez le résoudre de manière très simple en invoquant simplement l'entrée. Cependant, si vous appuyez sur, Enterla console disparaîtra à nouveau. Utilisez simplement ceci Console.ReadLine();ouConsole.Read();

Ajoutez ce qui suit avant le retour 0:

system("PAUSE");  

Cela imprime une ligne pour frapper une touche pour fermer la fenêtre. Il gardera la fenêtre ouverte jusqu'à ce que vous appuyiez sur la touche Entrée. Je demande à mes étudiants de l'ajouter à tous leurs programmes.

Selon ma préoccupation, si nous voulons stabiliser la SORTIE DE L'APPLICATION CONSOLE, jusqu'à la fermeture de la sortie affiche USE, le label: après la MainMethod, et goto label; avant la fin du programme

Dans le programme.

par exemple:

static void Main(string[] args)
{
    label:

    // Snippet of code

    goto label;
}