Почему окно консоли закрывается сразу после отображения моего вывода?

Я изучаю C #, следуя инструкциям в MSDN .

Теперь я только что попробовал Пример 1 ( здесь ссылка на MSDN ), и я столкнулся с проблемой: почему окно консоли закрывается сразу после отображения моего вывода?

using System;

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

проблема здесь в том, что их Hello World Program показывает, то она будет немедленно закрыта.
это почему?

Потому что это закончено. Когда консольные приложения завершат выполнение и вернутся из своего mainметода, соответствующее консольное окно автоматически закроется. Это ожидаемое поведение.

Если вы хотите, чтобы он оставался открытым для целей отладки, вам нужно будет дать компьютеру команду подождать нажатия клавиши, прежде чем завершать работу приложения и закрывать окно.

Console.ReadLineМетод является одним из способов сделать это. Добавление этой строки в конец кода (непосредственно перед returnоператором) приведет к тому, что приложение будет ждать, пока вы нажмете клавишу, прежде чем выйти.

В качестве альтернативы, вы можете запустить приложение без подключенного отладчика, нажав « Ctrl+» F5в среде Visual Studio, но это имеет очевидный недостаток, заключающийся в том, что вы не можете использовать функции отладки, которые вы, вероятно, захотите использовать при написании приложения.

Наилучшим компромиссом, вероятно, является вызов Console.ReadLineметода только при отладке приложения, заключая его в директиву препроцессора. Что-то вроде:

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

Вы также можете захотеть, чтобы окно оставалось открытым, если было выброшено необработанное исключение. Для этого вы можете поместить Console.ReadLine();в finallyблок:

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

Вместо того, чтобы использовать

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

Вы можете запустить вашу программу, используя Ctrl+ F5(если вы находитесь в Visual Studio). Затем Visual Studio будет держать окно консоли открытым, пока вы не нажмете клавишу.

Примечание: вы не можете отлаживать свой код в этом подходе.

Я предполагаю, что причина, по которой вы не хотите, чтобы он закрывался в режиме отладки, заключается в том, что вы хотите посмотреть значения переменных и т. Д. Поэтому, вероятно, лучше всего просто вставить точку останова в закрывающую "}" главной функции. , Если вам не нужно отлаживать, то Ctrl-F5 - лучший вариант.

Это ведет себя так же для CtrlF5или F5. Поместите непосредственно перед концом Mainметода.

using System.Diagnostics;

private static void Main(string[] args) {

  DoWork();

  if (Debugger.IsAttached) {
    Console.WriteLine("Press any key to continue . . .");
    Console.ReadLine();
  }
}

Программа немедленно закрывается, потому что ничто не мешает ей закрыться. Вставьте точку останова на return 0;или добавьте Console.Read();перед, return 0;чтобы предотвратить закрытие программы.

Я немного опоздал на вечеринку, но: в Visual Studio 2019 для проектов .NET Core консоль не закрывается автоматически по умолчанию. Вы можете настроить поведение через меню Инструменты → Параметры → Отладка → Общие → Автоматически закрыть консоль, когда отладка останавливается. Если окно консоли закрывается автоматически, проверьте, не задан ли упомянутый параметр.

То же самое относится и к консольным проектам нового стиля .NET Framework:

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

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

</Project>

Старый стиль .NET Framework по-прежнему безоговорочно закрывал консоль в конце (начиная с Visual Studio 16.0.1).

Ссылка: https://devblogs.microsoft.com/dotnet/net-core-tooling-update-for-visual-studio-2019-preview-2/

Если вы хотите, чтобы ваше приложение было открыто, вам нужно что-то сделать, чтобы поддержать его процесс. Приведенный ниже пример является самым простым, который нужно поместить в конец вашей программы:

while (true) ;

Тем не менее, это вызовет перегрузку ЦП, поскольку он вынужден выполнять итерации бесконечно.

На этом этапе вы можете выбрать использование System.Windows.Forms.Applicationкласса (но для этого необходимо добавить System.Windows.Formsссылку):

Application.Run();

Это не пропускает процессор и работает успешно

Чтобы избежать добавления System.Windows.Formsссылки, вы можете использовать простой трюк, так называемое ожидание вращения , импортирующий System.Threading:

SpinWait.SpinUntil(() => false);

Это также отлично работает и в основном состоит из whileцикла с отрицательным условием, которое возвращается вышеприведенным лямбда-методом. Почему это не перегрузка процессора? Вы можете посмотреть исходный код здесь ; во всяком случае, он в основном ждет некоторого цикла процессора, прежде чем перебирать.

Вы также можете создать зацикливатель сообщений, который просматривает ожидающие сообщения из системы и обрабатывает каждое из них, прежде чем перейти к следующей итерации, следующим образом:

[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;
}

Затем вы можете безопасно выполнить цикл, выполнив что-то вроде этого:

while (true)
    ProcessMessageOnce();

Кроме того, вы можете отложить закрытие, используя следующий код:

System.Threading.Thread.Sleep(1000);

Обратите внимание, что Sleepиспользуется миллисекунды.

Другой способ - использовать Debugger.Break()перед возвратом из метода Main.

Код закончен, для продолжения необходимо добавить это:

Console.ReadLine();

или

Console.Read();

Используйте Console.Read (); чтобы предотвратить закрытие программы, но убедитесь, что вы добавили Console.Read();код перед оператором возврата, иначе это будет недоступный код.

    Console.Read(); 
    return 0; 

проверить эту консоль.Читать

Добавьте Readметод, чтобы показать вывод.

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

Вот способ сделать это без участия Console:

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

Программа закрывается, как только ее выполнение завершено. В этом случае, когда вы return 0;. Это ожидаемая функциональность. Если вы хотите увидеть вывод, то либо запустите его вручную в терминале, либо установите ожидание в конце программы, чтобы он оставался открытым в течение нескольких секунд (используя библиотеку потоков).

это асинхронный ответ в консольном приложении в C #?

все, что есть в консольном приложении, никогда не использовать, awaitа использовать theAsyncMethod().GetAwaiter().GetResult();,

пример

var result = await HttpClientInstance.SendAsync(message);

становится

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

если ваша программа требует, чтобы вы продолжили нажимать клавишу ввода, как вы должны ввести значение и продолжить, затем добавьте новый double или int и введите write перед retunr (0); scanf_s ("% lf" & переменная);

Я всегда добавляю следующее заявление в консольное приложение. (Создайте фрагмент кода для этого, если хотите)

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

Это помогает, когда вы хотите экспериментировать с различными концепциями через консольное приложение.

Ctr + F5 заставит консоль остаться, но вы не можете отлаживать! Все консольные приложения, которые я написал в реальном мире, всегда неинтерактивны и запускаются планировщиком, таким как рабочая станция TWS или CA, и не требуют чего-то подобного.

Чтобы упростить то, что говорят другие: используйте Console.ReadKey();.

Это делает так, что программа ждет пользователя, чтобы нажать нормальную клавишу на клавиатуре

Источник: я использую его в своих программах для консольных приложений.

Вы можете решить это очень простым способом, просто вызвав ввод. Однако, если вы нажмете, Enterконсоль снова отключится. Просто используйте это Console.ReadLine();илиConsole.Read();

Добавьте следующее до возврата 0:

system("PAUSE");  

Это печатает строку, чтобы нажать клавишу, чтобы закрыть окно. Это будет держать окно вверх, пока вы не нажмете клавишу ввода. Мои ученики добавили его во все свои программы.

Согласно моему беспокойству, если мы хотим стабилизировать ВЫХОД КОНСОЛЬНОГО ПРИЛОЖЕНИЯ, до закрытия вывода отобразится ИСПОЛЬЗОВАНИЕ, метка: после MainMethod и метка goto; до завершения программы

В программе.

например:

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

    // Snippet of code

    goto label;
}