Como executar um aplicativo de console C # com o console oculto

Existe uma maneira de ocultar a janela do console ao executar um aplicativo de console?

Atualmente, estou usando um aplicativo Windows Forms para iniciar um processo do console, mas não quero que a janela do console seja exibida enquanto a tarefa estiver em execução.

Se você estiver usando a ProcessStartInfoclasse, poderá definir o estilo da janela como oculto - no caso de aplicativos de console (não GUI), será necessário configurar o CreateNoWindow para true:

System.Diagnostics.ProcessStartInfo start =
      new System.Diagnostics.ProcessStartInfo();
start.FileName = dir + @"\Myprocesstostart.exe";
start.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden; //Hides GUI
start.CreateNoWindow = true; //Hides console

Se você escreveu o aplicativo de console, pode ocultá-lo por padrão.

Crie um novo aplicativo de console e altere o tipo "Tipo de saída" para "Aplicativo do Windows" (feito nas propriedades do projeto)

Se você estiver usando Process Class, poderá escrever

yourprocess.StartInfo.UseShellExecute = false;
yourprocess.StartInfo.CreateNoWindow = true;

antes yourprocess.start();e o processo ficará oculto

A resposta simples é: Acesse as propriedades do aplicativo do console (propriedades do projeto). Na guia "Aplicativo", altere o "Tipo de saída" para "Aplicativo do Windows". Isso é tudo.

Você pode usar a API do FreeConsole para desanexar o console do processo:

[DllImport("kernel32.dll")]
static extern bool FreeConsole();

(é claro que isso é aplicável apenas se você tiver acesso ao código fonte do aplicativo do console)

Se você estiver interessado na saída, pode usar esta função:

private static string ExecCommand(string filename, string arguments)
{
    Process process = new Process();
    ProcessStartInfo psi = new ProcessStartInfo(filename);
    psi.Arguments = arguments;
    psi.CreateNoWindow = true;
    psi.RedirectStandardOutput = true;
    psi.RedirectStandardError = true;
    psi.UseShellExecute = false;
    process.StartInfo = psi;

    StringBuilder output = new StringBuilder();
    process.OutputDataReceived += (sender, e) => { output.AppendLine(e.Data); };
    process.ErrorDataReceived += (sender, e) => { output.AppendLine(e.Data); };

    // run the process
    process.Start();

    // start reading output to events
    process.BeginOutputReadLine();
    process.BeginErrorReadLine();

    // wait for process to exit
    process.WaitForExit();

    if (process.ExitCode != 0)
        throw new Exception("Command " + psi.FileName + " returned exit code " + process.ExitCode);

    return output.ToString();
}

Ele executa o programa de linha de comando especificado, aguarda o término e retorna a saída como string.

Se você estiver criando um programa que não exija entrada do usuário, sempre poderá criá-lo como um serviço. Um serviço não mostra nenhum tipo de interface do usuário.

Adicione isso à sua classe para importar o arquivo DLL:

[DllImport("user32.dll")] 
static extern bool ShowWindow(IntPtr hWnd, int nCmdShow); 

[DllImport("kernel32.dll")] 
static extern IntPtr GetConsoleWindow();

const int SW_HIDE = 0;
const int SW_SHOW = 5;

E então, se você deseja ocultá-lo, use este comando:

 var handle = GetConsoleWindow();
 ShowWindow(handle, SW_HIDE);

E se você quiser mostrar o console:

var handle = GetConsoleWindow();
ShowWindow(handle, SW_SHOW);

Sei que não estou respondendo exatamente o que você deseja, mas estou me perguntando se você está fazendo a pergunta certa.

Por que você também não usa:

1. serviço do windows
2. crie um novo encadeamento e execute seu processo nesse

Essas opções parecem melhores se tudo o que você quer é executar um processo.

Embora, como outras respostas aqui tenham dito, você possa alterar o "Tipo de saída" para "Aplicativo do Windows", saiba que isso significa que você não pode usá- Console.Inlo, pois ele se tornará um NullStreamReader.

Console.Oute Console.Errorparece ainda funcionar bem no entanto.

Com base na resposta de Adam Markowitz acima, o seguinte funcionou para mim:

process = new Process();
process.StartInfo = new ProcessStartInfo("cmd.exe", "/k \"" + CmdFilePath + "\"");
process.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
//process.StartInfo.UseShellExecute = false;
//process.StartInfo.CreateNoWindow = true;
process.Start();

Eu tenho uma solução geral para compartilhar:

using System;
using System.Runtime.InteropServices;

namespace WhateverNamepaceYouAreUsing
{
    class Magician
    {
        [DllImport("kernel32.dll")]
        static extern IntPtr GetConsoleWindow();

        [DllImport("user32.dll")]
        static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);

        const int HIDE = 0;
        const int SHOW = 5;

        public static void DisappearConsole()
        {
            ShowWindow(GetConsoleWindow(), HIDE);
        }
    }
}

Basta incluir esta classe no seu projeto e ligar Magician.DisappearConsole();.

Um console piscará quando você iniciar o programa clicando nele. Ao executar no prompt de comando, o prompt de comando desaparece logo após a execução.

Eu faço isso para um Discord Bot que roda para sempre no fundo do meu computador como um processo invisível. Era mais fácil do que fazer o TopShelf trabalhar para mim. Alguns tutoriais do TopShelf falharam antes de eu escrever isso com alguma ajuda do código que encontrei em outro lugar. ; P

Eu também tentei simplesmente alterar as configurações no Visual Studio> Projeto> Propriedades> Aplicativo para iniciar como um aplicativo do Windows em vez de um aplicativo de console, e algo sobre o meu projeto impediu que isso ocultasse meu console - talvez porque o DSharpPlus exija iniciar um console na inicialização . Eu não sei. Seja qual for o motivo, essa classe me permite matar facilmente o console depois que ele aparece.

Espero que este mago ajude alguém. ;)

Apenas escreva

ProcessStartInfo psi= new ProcessStartInfo("cmd.exe");
......

psi.CreateNoWindow = true;