Exécuter les commandes d'invite de commandes

Existe-t-il un moyen d'exécuter des commandes d'invite de commandes à partir d'une application C #? Si oui, comment pourrais-je procéder comme suit:

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

Cela incorpore essentiellement un fichier RAR dans l'image JPG. Je me demandais simplement s'il y avait un moyen de le faire automatiquement en C #.

c'est tout ce que vous avez à faire exécuter des commandes shell à partir de C #

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

ÉDITER:

C'est pour cacher la fenêtre 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();

EDIT: 2

Il est important que l'argument commence par /Csinon il ne fonctionnera pas. Comment Scott Ferguson a dit: il "Exécute la commande spécifiée par la chaîne puis se termine."

J'ai essayé la solution @RameshVel mais je n'ai pas pu passer d'arguments dans mon application console. Si quelqu'un rencontre le même problème, voici une solution:

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

Aucune des réponses ci-dessus n'a aidé pour une raison quelconque, il semble qu'elles balaient les erreurs sous le tapis et rendent le dépannage de sa commande difficile. J'ai donc fini par faire quelque chose comme ça, peut-être que cela aidera quelqu'un d'autre:

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

Bien que techniquement cela ne réponde pas directement à la question posée, cela répond à la question de savoir comment faire ce que l'affiche originale voulait faire: combiner des fichiers. Si quoi que ce soit, c'est un article pour aider les débutants à comprendre de quoi parlent Instance Hunter et Konstantin.

C'est la méthode que j'utilise pour combiner des fichiers (dans ce cas un jpg et un zip). Notez que je crée un tampon qui est rempli avec le contenu du fichier zip (en petits morceaux plutôt qu'en une grande opération de lecture), puis le tampon est écrit à l'arrière du fichier jpg jusqu'à la fin du fichier zip. atteint:

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

si vous voulez garder la fenêtre cmd ouverte ou si vous voulez l'utiliser dans winform / wpf alors utilisez-la comme ceci

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

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

/ K

Gardera la fenêtre cmd ouverte

Oui, il y en a (voir le lien dans le commentaire de Matt Hamilton), mais il serait plus facile et mieux d'utiliser les classes IO de .NET. Vous pouvez utiliser File.ReadAllBytes pour lire les fichiers, puis File.WriteAllBytes pour écrire la version "intégrée".

Vous pouvez le faire en utilisant CliWrap sur une seule ligne:

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

en référence à Microsoft.VisualBasic

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

Voici une petite version de code simple et moins. Cela masquera également la fenêtre de la 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();

si vous souhaitez exécuter la commande en mode asynchrone - et imprimer les résultats. vous pouvez vous cette 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
        }
    }

}

Vous pouvez y parvenir en utilisant la méthode suivante (comme mentionné dans d'autres réponses):

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

Lorsque j'ai essayé les méthodes répertoriées ci-dessus, j'ai constaté que ma commande personnalisée ne fonctionnait pas en utilisant la syntaxe de certaines des réponses ci-dessus.

J'ai découvert que des commandes plus complexes doivent être encapsulées entre guillemets pour fonctionner:

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

vous pouvez utiliser simplement écrire le code dans une .batextension de format, le code du fichier batch:

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

utilisez ce code c #:

Process.Start("file_name.bat")