Führen Sie Eingabeaufforderungsbefehle aus

Gibt es eine Möglichkeit, Eingabeaufforderungsbefehle in einer C # -Anwendung auszuführen? Wenn ja, wie würde ich Folgendes tun:

copy /b Image1.jpg + Archive.rar Image2.jpg

Dadurch wird im Grunde eine RAR-Datei in das JPG-Bild eingebettet. Ich habe mich nur gefragt, ob es eine Möglichkeit gibt, dies in C # automatisch zu tun.

Dies ist alles, was Sie tun müssen, um Shell-Befehle von C # aus auszuführen

string strCmdText;
strCmdText= "/C copy /b Image1.jpg + Archive.rar Image2.jpg";
System.Diagnostics.Process.Start("CMD.exe",strCmdText);

BEARBEITEN:

Dies dient zum Ausblenden des Cmd-Fensters.

System.Diagnostics.Process process = new System.Diagnostics.Process();
System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
startInfo.FileName = "cmd.exe";
startInfo.Arguments = "/C copy /b Image1.jpg + Archive.rar Image2.jpg";
process.StartInfo = startInfo;
process.Start();

BEARBEITEN: 2

Wichtig ist, dass das Argument mit beginnt, /Csonst funktioniert es nicht. Wie Scott Ferguson sagte: "Führt den durch die Zeichenfolge angegebenen Befehl aus und wird dann beendet."

Versuchte @ RameshVel-Lösung, aber ich konnte keine Argumente in meiner Konsolenanwendung übergeben. Wenn jemand das gleiche Problem hat, ist hier eine Lösung:

using System.Diagnostics;

Process cmd = new Process();
cmd.StartInfo.FileName = "cmd.exe";
cmd.StartInfo.RedirectStandardInput = true;
cmd.StartInfo.RedirectStandardOutput = true;
cmd.StartInfo.CreateNoWindow = true;
cmd.StartInfo.UseShellExecute = false;
cmd.Start();

cmd.StandardInput.WriteLine("echo Oscar");
cmd.StandardInput.Flush();
cmd.StandardInput.Close();
cmd.WaitForExit();
Console.WriteLine(cmd.StandardOutput.ReadToEnd());

var proc1 = new ProcessStartInfo();
string anyCommand; 
proc1.UseShellExecute = true;

proc1.WorkingDirectory = @"C:\Windows\System32";

proc1.FileName = @"C:\Windows\System32\cmd.exe";
proc1.Verb = "runas";
proc1.Arguments = "/c "+anyCommand;
proc1.WindowStyle = ProcessWindowStyle.Hidden;
Process.Start(proc1);

Keine der oben genannten Antworten hat aus irgendeinem Grund geholfen. Es scheint, als würden sie Fehler unter den Teppich kehren und die Fehlerbehebung beim Befehl erschweren. Also habe ich so etwas gemacht, vielleicht hilft es jemand anderem:

var proc = new Process
{
    StartInfo = new ProcessStartInfo
    {
        FileName = @"C:\Program Files\Microsoft Visual Studio 14.0\Common7\IDE\tf.exe",
        Arguments = "checkout AndroidManifest.xml",
        UseShellExecute = false,
        RedirectStandardOutput = true,
        CreateNoWindow = true,
        WorkingDirectory = @"C:\MyAndroidApp\"
    }
};

proc.Start();

Obwohl dies technisch gesehen die gestellte Frage nicht direkt beantwortet, beantwortet es die Frage, wie das zu tun ist, was das Originalplakat tun wollte: Dateien kombinieren. Wenn überhaupt, ist dies ein Beitrag, der Neulingen hilft zu verstehen, worüber Instance Hunter und Konstantin sprechen.

Dies ist die Methode, mit der ich Dateien kombiniere (in diesem Fall ein JPG und ein Zip). Beachten Sie, dass ich einen Puffer erstelle, der mit dem Inhalt der Zip-Datei gefüllt wird (in kleinen Blöcken anstatt in einem großen Lesevorgang), und der Puffer dann bis zum Ende der Zip-Datei auf die Rückseite der JPG-Datei geschrieben wird erreicht:

private void CombineFiles(string jpgFileName, string zipFileName)
{
    using (Stream original = new FileStream(jpgFileName, FileMode.Append))
    {
        using (Stream extra = new FileStream(zipFileName, FileMode.Open, FileAccess.Read))
        {
            var buffer = new byte[32 * 1024];

            int blockSize;
            while ((blockSize = extra.Read(buffer, 0, buffer.Length)) > 0)
            {
                original.Write(buffer, 0, blockSize);
            }
        }
    }
}

Wenn Sie das Cmd-Fenster offen halten oder in winform / wpf verwenden möchten, verwenden Sie es wie folgt

    string strCmdText;
//For Testing
    strCmdText= "/K ipconfig";

 System.Diagnostics.Process.Start("CMD.exe",strCmdText);

/ K.

Hält das cmd-Fenster offen

Ja, das gibt es (siehe Link in Matt Hamiltons Kommentar), aber es wäre einfacher und besser, die E / A-Klassen von .NET zu verwenden. Sie können File.ReadAllBytes verwenden, um die Dateien zu lesen, und dann File.WriteAllBytes, um die "eingebettete" Version zu schreiben.

Sie können dies mit CliWrap in einer Zeile tun :

var stdout = new Cli("cmd")
         .Execute("copy /b Image1.jpg + Archive.rar Image2.jpg")
         .StandardOutput;

mit einem Verweis auf Microsoft.VisualBasic

Interaction.Shell("copy /b Image1.jpg + Archive.rar Image2.jpg", AppWinStyle.Hide);

Hier ist wenig einfache und weniger Code-Version. Das Konsolenfenster wird ebenfalls ausgeblendet.

System.Diagnostics.Process process = new System.Diagnostics.Process();
process.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
process.StartInfo.FileName = "cmd.exe";
process.StartInfo.Arguments = "/C copy /b Image1.jpg + Archive.rar Image2.jpg";
process.Start();

Wenn Sie den Befehl im asynchronen Modus ausführen und die Ergebnisse drucken möchten. Sie können Sie diese Klasse:

    public static class ExecuteCmd
{
    /// <summary>
    /// Executes a shell command synchronously.
    /// </summary>
    /// <param name="command">string command</param>
    /// <returns>string, as output of the command.</returns>
    public static void ExecuteCommandSync(object command)
    {
        try
        {
            // create the ProcessStartInfo using "cmd" as the program to be run, and "/c " as the parameters.
            // Incidentally, /c tells cmd that we want it to execute the command that follows, and then exit.
            System.Diagnostics.ProcessStartInfo procStartInfo = new System.Diagnostics.ProcessStartInfo("cmd", "/c " + command);
            // The following commands are needed to redirect the standard output. 
            //This means that it will be redirected to the Process.StandardOutput StreamReader.
            procStartInfo.RedirectStandardOutput =  true;
            procStartInfo.UseShellExecute = false;
            // Do not create the black window.
            procStartInfo.CreateNoWindow = true;
            // Now we create a process, assign its ProcessStartInfo and start it
            System.Diagnostics.Process proc = new System.Diagnostics.Process();
            proc.StartInfo = procStartInfo;
            proc.Start();

            // Get the output into a string
            string result = proc.StandardOutput.ReadToEnd();

            // Display the command output.
            Console.WriteLine(result);
        }
        catch (Exception objException)
        {
            // Log the exception
            Console.WriteLine("ExecuteCommandSync failed" + objException.Message);
        }
    }

    /// <summary>
    /// Execute the command Asynchronously.
    /// </summary>
    /// <param name="command">string command.</param>
    public static void ExecuteCommandAsync(string command)
    {
        try
        {
            //Asynchronously start the Thread to process the Execute command request.
            Thread objThread = new Thread(new ParameterizedThreadStart(ExecuteCommandSync));
            //Make the thread as background thread.
            objThread.IsBackground = true;
            //Set the Priority of the thread.
            objThread.Priority = ThreadPriority.AboveNormal;
            //Start the thread.
            objThread.Start(command);
        }
        catch (ThreadStartException )
        {
            // Log the exception
        }
        catch (ThreadAbortException )
        {
            // Log the exception
        }
        catch (Exception )
        {
            // Log the exception
        }
    }

}

Sie können dies mit der folgenden Methode erreichen (wie in anderen Antworten erwähnt):

strCmdText = "'/C some command";
Process.Start("CMD.exe", strCmdText);

Als ich die oben aufgeführten Methoden ausprobierte, stellte ich fest, dass mein benutzerdefinierter Befehl mit der Syntax einiger der obigen Antworten nicht funktionierte.

Ich fand heraus, dass komplexere Befehle in Anführungszeichen gesetzt werden müssen, um zu funktionieren:

string strCmdText;
strCmdText = "'/C cd " + path + " && composer update && composer install -o'";
Process.Start("CMD.exe", strCmdText);

Sie können einfach den Code in einer Formaterweiterung schreiben .bat, den Code der Batch-Datei:

c:/ copy /b Image1.jpg + Archive.rar Image2.jpg

Verwenden Sie diesen C # -Code:

Process.Start("file_name.bat")