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

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

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

using System;

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

ОТВЕТЫ

Ответ 1

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

Потому что он закончил. Когда консольные приложения завершили выполнение и возвращаются из 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

Ответ 2

Вместо использования

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

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

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

Ответ 3

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

using System.Diagnostics;

private static void Main(string[] args) {

  DoWork();

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

Ответ 4

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

Ответ 5

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

Ответ 6

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

System.Threading.Thread.Sleep(1000);

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

Ответ 7

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

Ответ 8

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

Console.ReadLine();

или

Console.Read();

Ответ 9

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

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

Ответ 10

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

    Console.Read(); 
    return 0;

проверьте Console.Read

Ответ 11

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

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();

Еще лучше, если вы могли бы смешать два последних решения, заменив while итератор с SpinWait.SpinUntil вызова:

SpinWait.SpinUntil(ProcessMessageOnce);

Ответ 12

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

Ответ 13

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

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

пример

var result = await HttpClientInstance.SendAsync(message);

становится

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

Ответ 14

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

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

Ответ 15

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

system("PAUSE");

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

Ответ 16

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

Ответ 17

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

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

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

Ответ 18

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

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

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

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

Ответ 19

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

Ответ 20

Согласно моему беспокойству, если мы хотим стабилизировать OUTPUT OF CONSOLE APPLICATION, до закрытия вывода отображается USE, метка: после MainMethod и метка goto; до завершения программы

В программе.

например:

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

    // Snippet of code

    goto label;
}