Esegui comandi prompt dei comandi

Esiste un modo per eseguire i comandi del prompt dei comandi dall'interno di un'applicazione C #? In tal caso, come farei quanto segue:

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

Questo fondamentalmente incorpora un file RAR nell'immagine JPG. Mi stavo solo chiedendo se ci fosse un modo per farlo automaticamente in C #.

questo è tutto ciò che devi fare per eseguire comandi shell da C #

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

MODIFICARE:

Questo serve a nascondere la finestra cmd.

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

MODIFICA: 2

Importante è che l'argomento inizi con /Caltrimenti non funzionerà. Come ha detto Scott Ferguson : "Esegue il comando specificato dalla stringa e quindi termina".

Ho provato la soluzione @RameshVel ma non sono riuscito a passare argomenti nella mia applicazione console. Se qualcuno ha lo stesso problema, ecco una soluzione:

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

Nessuna delle risposte di cui sopra ha aiutato per qualche motivo, sembra che spazzino gli errori sotto il tappeto e rendano difficile la risoluzione dei problemi del comando. Quindi ho finito con qualcosa del genere, forse aiuterà qualcun altro:

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

Sebbene tecnicamente questo non risponda direttamente alla domanda posta, risponde alla domanda su come fare ciò che il poster originale voleva fare: combinare i file. Semmai, questo è un post per aiutare i neofiti a capire di cosa parlano Instance Hunter e Konstantin.

Questo è il metodo che uso per combinare i file (in questo caso un jpg e uno zip). Si noti che creo un buffer che viene riempito con il contenuto del file zip (in piccoli blocchi piuttosto che in una grande operazione di lettura), quindi il buffer viene scritto sul retro del file jpg fino alla fine del file zip raggiunto:

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

se vuoi tenere aperta la finestra cmd o vuoi usarla in winform / wpf, usala in questo modo

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

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

/K

Manterrà aperta la finestra cmd

Sì, c'è (vedi link nel commento di Matt Hamilton), ma sarebbe più facile e migliore usare le classi IO di .NET. È possibile utilizzare File.ReadAllBytes per leggere i file e quindi File.WriteAllBytes per scrivere la versione "incorporata".

Puoi farlo usando CliWrap in una riga:

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

con riferimento a Microsoft.VisualBasic

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

Ecco una versione poco semplice e meno in codice. Nasconderà anche la finestra della console-

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

se si desidera eseguire il comando in modalità asincrona - e stampare i risultati. puoi questa classe:

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

}

È possibile ottenere ciò utilizzando il seguente metodo (come indicato in altre risposte):

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

Quando ho provato i metodi sopra elencati ho scoperto che il mio comando personalizzato non funzionava usando la sintassi di alcune delle risposte sopra.

Ho scoperto che i comandi più complessi devono essere incapsulati tra virgolette per funzionare:

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

puoi semplicemente scrivere il codice in .batun'estensione di formato, il codice del file batch:

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

usa questo codice c #:

Process.Start("file_name.bat")