Wie eine C # Konsolenanwendung mit der Konsole läuft versteckt

Question

Gibt es eine Möglichkeit das Konsolenfenster zu verstecken, wenn eine Konsole-Anwendung ausgeführt wird?

Ich bin derzeit mit Windows Forms-Anwendung, eine Konsole zu starten, aber ich will nicht das Konsolenfenster angezeigt werden, während die Aufgabe ausgeführt wird.

Answer 1

Wenn Sie die ProcessStartInfo Klasse verwenden Sie das Fenster Stil versteckt festlegen:

System.Diagnostics.ProcessStartInfo start =
      new System.Diagnostics.ProcessStartInfo();
start.FileName = dir + @"\Myprocesstostart.exe";
start.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;

Answer 2

Wenn Sie die Konsolenanwendung geschrieben Sie können es standardmäßig ausgeblendet werden.

Erstellen Sie eine neue Konsolenanwendung dann ändern Sie dann den „Ausgabetyp“ Typen „Windows Application“ (in den Projekteigenschaften durchgeführt)

Answer 3

Wenn Sie Prozess Klasse verwenden, dann können Sie schreiben

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

vor yourprocess.start(); und Verfahren werden ausgeblendet

Answer 4

Einfache Antwort ist, dass: Gehen Sie zu Ihrer Konsole App Eigenschaften (Projekteigenschaften) .In der „Application“ Registerkarte nur den „Ausgangstyp“ auf „Windows-Anwendung“. Das ist alles.

Answer 5

Sie können die FreeConsole API die Konsole aus dem Prozess zu lösen:

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

(natürlich dies gilt nur, wenn Sie den Zugriff auf die Konsole-Anwendung des Quellcode haben)

Answer 6

Wenn Sie in der Ausgabe interessiert sind, können Sie diese Funktion verwenden:

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

Es wird mit dem Kommandozeilen-Programm gegeben, wartet, bis es beendet und die Ausgabe als String zurück.

Answer 7

Wenn Sie ein Programm erstellen, die keine Benutzereingaben erfordern könnte man immer nur als Dienst erstellen. Ein Dienst wird nicht angezeigt, jede Art von UI.

Answer 8

Ich weiß, dass ich nicht genau bin zu beantworten, was Sie wollen, aber ich frage mich, ob Sie die richtige Frage sind zu fragen.

Warum Sie nicht verwenden entweder:

1. Windows-Dienst
2. einen neuen Thread erstellen und Verfahren auf das ausführen

Die klingen wie bessere Möglichkeiten, wenn alles, was Sie wollen, ist ein Prozess ausgeführt werden.

Answer 9

Fügen Sie diese in Ihrer Klasse die DLL-Datei zu importieren:

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

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

Und dann, wenn Sie es verwenden, um diesen Befehl verbergen wollen:

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

Und wenn Sie möchten, um die Konsole zeigen:

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

Answer 10

Auf der Grundlage von Adam Markowitz Antwort oben, nach für mich gearbeitet:

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

Answer 11

Ich habe eine allgemeine Lösung bekam zu teilen:

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

Just umfassen diese Klasse in Ihrem Projekt und rufen Magician.DisappearConsole();.

Eine Konsole blinkt, wenn Sie das Programm durch einen Klick auf starten. Wenn an der Eingabeaufforderung ausgeführt wird, die Eingabeaufforderung verschwindet kurz nach der Ausführung.

Ich tue dies für einen Discord Bot, die im Hintergrund von meinem Computer läuft immer als unsichtbarer Prozess. Es war leichter, als ich Topshelf für mich zu arbeiten. Ein paar Topshelf Tutorials gescheitert mich, bevor ich dies mit etwas Hilfe von Code schrieb ich an anderer Stelle gefunden. ; P

ich einfach auch versucht, die Einstellungen in Visual Studio Ändern> Projekt> Eigenschaften> Anwendung als Windows-Anwendung zu starten, statt einer Konsole-Anwendung, und etwas über mein Projekt das aus seinem Versteck meine Konsole verhindert - vielleicht, weil DSharpPlus Anforderungen starten einen Konsole beim Start. Ich weiß es nicht. Was auch immer der Grund ist, ermöglicht diese Klasse mir einfach die Konsole zu töten, nachdem sie herausspringt.

Hope this Magier jemand hilft. ;)

Answer 12

Schreiben Sie einfach

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

psi.CreateNoWindow = true;

Answer 13

Obwohl, wie andere Antworten hier gesagt haben, können Sie den „Ausgangstyp“ auf „Windows-Anwendung“, bitte beachten Sie, dass dies bedeutet, dass Sie nicht Console.In verwenden können, wie es ein NullStreamReader werden wird.

Console.Out und Console.Error scheinen jedoch immer noch gut zu funktionieren.