Comment afficher la sortie d'une commande en temps réel dans une zone de texte Windows Forms ?

Ce code montre comment exécuter un processus de ligne de commande et afficher sa sortie en temps réel dans une zone de texte Windows Forms. Affinons-le pour plus de clarté et de robustesse.

Code amélioré :

Cette version ajoute une gestion des erreurs, des noms de variables plus clairs et des pratiques de threading améliorées.

<code class="language-csharp">using System;
using System.Diagnostics;
using System.Text;
using System.Threading;
using System.Windows.Forms;

public static class CommandExecutor
{
    public delegate void OutputHandler(string line);

    public static int Run(string workingDirectory, string command, string arguments, 
                          OutputHandler outputHandler, bool hideWindow = true)
    {
        int exitCode = -1; // Initialize to an invalid value

        try
        {
            using (var process = new Process())
            {
                process.StartInfo.FileName = "cmd.exe";
                process.StartInfo.WorkingDirectory = workingDirectory;
                process.StartInfo.Arguments = $"/c \"{command} {arguments}\" 2>&1"; // Redirect stderr to stdout
                process.StartInfo.CreateNoWindow = hideWindow;
                process.StartInfo.UseShellExecute = false;
                process.StartInfo.RedirectStandardOutput = true;
                process.StartInfo.RedirectStandardError = true;

                if (outputHandler != null)
                {
                    process.OutputDataReceived += (sender, e) =>
                    {
                        if (e.Data != null)
                        {
                            outputHandler(e.Data);
                        }
                    };
                    process.ErrorDataReceived += (sender, e) =>
                    {
                        if (e.Data != null)
                        {
                            outputHandler($"Error: {e.Data}"); //Clearly mark error messages
                        }
                    };
                }

                process.Start();

                if (outputHandler != null)
                {
                    process.BeginOutputReadLine();
                    process.BeginErrorReadLine(); //Begin reading error stream
                    process.WaitForExit();
                }
                else
                {
                    process.WaitForExit();
                }

                exitCode = process.ExitCode;
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show($"An error occurred: {ex.Message}", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }

        return exitCode;
    }

    public static string GetOutput(string workingDirectory, string command, string arguments)
    {
        StringBuilder output = new StringBuilder();
        Run(workingDirectory, command, arguments, line => output.AppendLine(line));
        return output.ToString();
    }
}


public partial class Form1 : Form
{
    private TextBox txtOutput; //Declare TextBox

    public Form1()
    {
        InitializeComponent();
        txtOutput = new TextBox { Dock = DockStyle.Fill, Multiline = true, ScrollBars = ScrollBars.Both };
        Controls.Add(txtOutput); // Add the TextBox to the form

        //Add a button (btnExecute) to your form in the designer.
    }

    private void btnExecute_Click(object sender, EventArgs e)
    {
        //Get command and arguments from your textboxes (e.g., textBoxCommand, textBoxArguments)
        string command = textBoxCommand.Text;
        string arguments = textBoxArguments.Text;

        CommandExecutor.Run(@"C:\", command, arguments, line =>
        {
            if (txtOutput.InvokeRequired)
            {
                txtOutput.Invoke(new MethodInvoker(() => txtOutput.AppendText(line + Environment.NewLine)));
            }
            else
            {
                txtOutput.AppendText(line + Environment.NewLine);
            }
        });
    }
}</code>

Améliorations clés :

• Gestion des erreurs : Le bloc try-catch gère les exceptions potentielles lors de l'exécution du processus.
• Nom plus clair : Des noms de variables plus descriptifs améliorent la lisibilité (CommandExecutor, workingDirectory).
• Gestion du flux d'erreurs : Le code lit et affiche désormais la sortie d'erreur de la commande.
• Sécurité des threads : La vérification InvokeRequired garantit la sécurité des threads lors de la mise à jour de TextBox à partir d'un fil d'arrière-plan.
• Environment.NewLine : Utilise Environment.NewLine pour des sauts de ligne cohérents sur toutes les plates-formes.
• Gestion simplifiée des arguments : Utilise l'interpolation de chaînes pour une construction d'arguments plus propre.
• Déclaration TextBox séparée : La TextBox est déclarée séparément pour une meilleure organisation.

N'oubliez pas d'ajouter une TextBox (par exemple, txtOutput) et un bouton (par exemple, btnExecute) à votre formulaire dans le concepteur Visual Studio. Vous aurez également besoin de zones de texte pour saisir la commande et ses arguments. Remplacez textBoxCommand et textBoxArguments par les noms réels de vos zones de texte. Ce code amélioré fournit une solution plus robuste et conviviale pour afficher le résultat des commandes en temps réel dans une application Windows Forms.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!