Come eseguire un'applicazione console C # con la console nascosta

C'è un modo per nascondere la finestra della console quando si esegue un'applicazione console?

Attualmente sto usando un'applicazione Windows Form per avviare un processo della console, ma non voglio che la finestra della console venga visualizzata mentre l'attività è in esecuzione.

Se si utilizza la ProcessStartInfoclasse, è possibile impostare lo stile della finestra su nascosto - nel caso di applicazioni console (non GUI), è necessario impostare CreateNoWindow su 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 hai scritto l'applicazione console, puoi renderla nascosta per impostazione predefinita.

Crea una nuova app console, quindi modifica il tipo "Tipo di output" in "Applicazione Windows" (fatto nelle proprietà del progetto)

Se si utilizza la classe di processo, è possibile scrivere

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

prima yourprocess.start();e il processo sarà nascosto

La semplice risposta è che: vai alle proprietà dell'app della tua console (proprietà del progetto). Nella scheda "Applicazione", modifica "Tipo di output" in "Applicazione Windows". È tutto.

Puoi usare l' API di FreeConsole per staccare la console dal processo:

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

(ovviamente questo è applicabile solo se si ha accesso al codice sorgente dell'applicazione console)

Se sei interessato all'output, puoi utilizzare questa funzione:

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

Esegue il programma della riga di comando specificato, attende che termini e restituisce l'output come stringa.

Se stai creando un programma che non richiede l'input dell'utente, puoi sempre crearlo come servizio. Un servizio non mostrerà alcun tipo di interfaccia utente.

Aggiungi questo alla tua classe per importare il file 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 poi se vuoi nasconderlo usa questo comando:

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

E se vuoi mostrare la console:

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

So che non sto rispondendo esattamente a quello che vuoi, ma mi chiedo se stai facendo la domanda giusta.

Perché non usi neanche:

1. servizio di windows
2. crea un nuovo thread ed esegui il tuo processo su quello

Sembrano opzioni migliori se tutto ciò che vuoi è eseguire un processo.

Sebbene come altre risposte qui abbiano detto che è possibile modificare il "Tipo di output" in "Applicazione Windows", tenere presente che ciò significa che non è possibile utilizzare Console.Inin quanto diventerà un NullStreamReader.

Console.Oute Console.Errorsembra comunque funzionare bene.

Sulla base della risposta di Adam Markowitz sopra, il seguente ha funzionato per me:

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

Ho una soluzione generale da condividere:

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

Includi questa classe nel tuo progetto e chiama Magician.DisappearConsole();.

Una console lampeggerà quando avvierai il programma facendo clic su di esso. Quando si esegue dal prompt dei comandi, il prompt dei comandi scompare molto poco dopo l'esecuzione.

Lo faccio per un Discord Bot che funziona per sempre sullo sfondo del mio computer come un processo invisibile. È stato più facile che far funzionare TopShelf per me. Un paio di tutorial su TopShelf mi hanno deluso prima di scriverlo con l'aiuto del codice che ho trovato altrove. ; P

Ho anche provato semplicemente a modificare le impostazioni in Visual Studio> Progetto> Proprietà> Applicazione da avviare come Applicazione Windows anziché come Applicazione Console, e qualcosa sul mio progetto ha impedito a questo di nascondere la mia console, forse perché DSharpPlus richiede di avviare una console all'avvio . Non lo so. Qualunque sia il motivo, questa classe mi permette di uccidere facilmente la console dopo che è stata visualizzata.

Spero che questo Mago aiuti qualcuno. ;)

Scrivi e basta

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

psi.CreateNoWindow = true;