Thực hiện hàng loạt tệp trong C #

Tôi đang cố gắng thực thi một tệp bó trong C #, nhưng tôi không gặp may mắn khi làm điều đó.

Tôi đã tìm thấy nhiều ví dụ trên Internet, nhưng nó không hoạt động với tôi.

public void ExecuteCommand(string command)
{
    int ExitCode;
    ProcessStartInfo ProcessInfo;
    Process Process;

    ProcessInfo = new ProcessStartInfo("cmd.exe", "/c " + command);
    ProcessInfo.CreateNoWindow = true;
    ProcessInfo.UseShellExecute = false;

    Process = Process.Start(ProcessInfo);
    Process.WaitForExit();

    ExitCode = Process.ExitCode;
    Process.Close();

    MessageBox.Show("ExitCode: " + ExitCode.ToString(), "ExecuteCommand");
}

Chuỗi lệnh chứa tên của tệp bó (được lưu trữ system32) và một số tệp cần thao tác. (Ví dụ txtmanipulator file1.txt file2.txt file3.txt:). Khi tôi thực hiện tệp bó theo cách thủ công, nó hoạt động chính xác.

Khi thực thi mã, nó cho tôi một **ExitCode: 1** (Catch all for general errors)

Tôi đang làm gì sai?

Điều này nên làm việc. Bạn có thể cố gắng loại bỏ nội dung của các luồng đầu ra và lỗi để tìm hiểu điều gì đang xảy ra:

static void ExecuteCommand(string command)
{
    int exitCode;
    ProcessStartInfo processInfo;
    Process process;

    processInfo = new ProcessStartInfo("cmd.exe", "/c " + command);
    processInfo.CreateNoWindow = true;
    processInfo.UseShellExecute = false;
    // *** Redirect the output ***
    processInfo.RedirectStandardError = true;
    processInfo.RedirectStandardOutput = true;

    process = Process.Start(processInfo);
    process.WaitForExit();

    // *** Read the streams ***
    // Warning: This approach can lead to deadlocks, see Edit #2
    string output = process.StandardOutput.ReadToEnd();
    string error = process.StandardError.ReadToEnd();

    exitCode = process.ExitCode;

    Console.WriteLine("output>>" + (String.IsNullOrEmpty(output) ? "(none)" : output));
    Console.WriteLine("error>>" + (String.IsNullOrEmpty(error) ? "(none)" : error));
    Console.WriteLine("ExitCode: " + exitCode.ToString(), "ExecuteCommand");
    process.Close();
}

static void Main()
{
    ExecuteCommand("echo testing");
}   

* BIÊN TẬP *

Đưa ra thông tin bổ sung trong bình luận của bạn dưới đây, tôi đã có thể tạo lại vấn đề. Dường như có một số cài đặt bảo mật dẫn đến hành vi này (chưa điều tra chi tiết về điều đó).

Điều này không hoạt động nếu tập tin bó không được đặt trong C:\Windows\System32. Hãy thử di chuyển nó đến một số vị trí khác, ví dụ như vị trí thực thi của bạn. Lưu ý rằng việc giữ các tệp bó tùy chỉnh hoặc tệp thực thi trong thư mục Windows là cách thực hành tồi.

* EDIT 2 * Nó quay ra rằng nếu các luồng được đọc đồng bộ, một bế tắc có thể xảy ra, hoặc là bằng cách đọc đồng bộ trước WaitForExithoặc bằng cách đọc cả hai stderrvà stdoutđồng bộ một sau khi khác.

Điều này không nên xảy ra nếu sử dụng các phương thức đọc không đồng bộ thay vào đó, như trong ví dụ sau:

static void ExecuteCommand(string command)
{
    var processInfo = new ProcessStartInfo("cmd.exe", "/c " + command);
    processInfo.CreateNoWindow = true;
    processInfo.UseShellExecute = false;
    processInfo.RedirectStandardError = true;
    processInfo.RedirectStandardOutput = true;

    var process = Process.Start(processInfo);

    process.OutputDataReceived += (object sender, DataReceivedEventArgs e) =>
        Console.WriteLine("output>>" + e.Data);
    process.BeginOutputReadLine();

    process.ErrorDataReceived += (object sender, DataReceivedEventArgs e) =>
        Console.WriteLine("error>>" + e.Data);
    process.BeginErrorReadLine();

    process.WaitForExit();

    Console.WriteLine("ExitCode: {0}", process.ExitCode);
    process.Close();
}

System.Diagnostics.Process.Start("c:\\batchfilename.bat");

dòng đơn giản này sẽ thực thi các tập tin bó.

Sau một số trợ giúp tuyệt vời từ steinar, đây là những gì làm việc cho tôi:

public void ExecuteCommand(string command)
{
    int ExitCode;
    ProcessStartInfo ProcessInfo;
    Process process;

    ProcessInfo = new ProcessStartInfo(Application.StartupPath + "\\txtmanipulator\\txtmanipulator.bat", command);
    ProcessInfo.CreateNoWindow = true;
    ProcessInfo.UseShellExecute = false;
    ProcessInfo.WorkingDirectory = Application.StartupPath + "\\txtmanipulator";
    // *** Redirect the output ***
    ProcessInfo.RedirectStandardError = true;
    ProcessInfo.RedirectStandardOutput = true;

    process = Process.Start(ProcessInfo);
    process.WaitForExit();

    // *** Read the streams ***
    string output = process.StandardOutput.ReadToEnd();
    string error = process.StandardError.ReadToEnd();

    ExitCode = process.ExitCode;

    MessageBox.Show("output>>" + (String.IsNullOrEmpty(output) ? "(none)" : output));
    MessageBox.Show("error>>" + (String.IsNullOrEmpty(error) ? "(none)" : error));
    MessageBox.Show("ExitCode: " + ExitCode.ToString(), "ExecuteCommand");
    process.Close();
}

Nó hoạt động tốt. Tôi đã thử nó như thế này:

String command = @"C:\Doit.bat";

ProcessInfo = new ProcessStartInfo("cmd.exe", "/c " + command);
// ProcessInfo.CreateNoWindow = true;

Tôi nhận xét tắt cửa sổ để tôi có thể XEM nó chạy.

Dưới đây là mẫu mã c # đang gửi 2 tham số đến tệp bat / cmd để trả lời câu hỏi này .

Nhận xét: làm thế nào tôi có thể truyền tham số và đọc kết quả thực hiện lệnh?

/ bởi @Janatbek Sharsheyev

Tùy chọn 1: Không ẩn cửa sổ giao diện điều khiển, truyền đối số và không nhận kết quả đầu ra

• Đây là bản chỉnh sửa từ câu trả lời này / bởi @Brian Rasmussen

  ---

using System;
using System.Diagnostics;


namespace ConsoleApplication
{
    class Program
    { 
        static void Main(string[] args)
        {
         System.Diagnostics.Process.Start(@"c:\batchfilename.bat", "\"1st\" \"2nd\"");
        }
    }
}

Tùy chọn 2: Ẩn cửa sổ giao diện điều khiển, truyền đối số và nhận đầu ra

using System;
using System.Diagnostics;

namespace ConsoleApplication
{
    class Program
    { 
        static void Main(string[] args)
        {
         var process = new Process();
         var startinfo = new ProcessStartInfo(@"c:\batchfilename.bat", "\"1st_arg\" \"2nd_arg\" \"3rd_arg\"");
         startinfo.RedirectStandardOutput = true;
         startinfo.UseShellExecute = false;
         process.StartInfo = startinfo;
         process.OutputDataReceived += (sender, argsx) => Console.WriteLine(argsx.Data); // do whatever processing you need to do in this handler
         process.Start();
         process.BeginOutputReadLine();
         process.WaitForExit();
        }
    }
}

Mã dưới đây làm việc tốt cho tôi

using System.Diagnostics;

public void ExecuteBatFile()
{
    Process proc = null;

    string _batDir = string.Format(@"C:\");
    proc = new Process();
    proc.StartInfo.WorkingDirectory = _batDir;
    proc.StartInfo.FileName = "myfile.bat";
    proc.StartInfo.CreateNoWindow = false;
    proc.Start();
    proc.WaitForExit();
    ExitCode = proc.ExitCode;
    proc.Close();
    MessageBox.Show("Bat file executed...");
}

using System.Diagnostics;

private void ExecuteBatFile()
{
    Process proc = null;
    try
    {
        string targetDir = string.Format(@"D:\mydir");   //this is where mybatch.bat lies
        proc = new Process();
        proc.StartInfo.WorkingDirectory = targetDir;
        proc.StartInfo.FileName = "lorenzo.bat";
        proc.StartInfo.Arguments = string.Format("10");  //this is argument
        proc.StartInfo.CreateNoWindow = false;
        proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;  //this is for hiding the cmd window...so execution will happen in back ground.
        proc.Start();
        proc.WaitForExit();
    }
    catch (Exception ex)
    {
        Console.WriteLine("Exception Occurred :{0},{1}", ex.Message, ex.StackTrace.ToString());
    }
}

Bạn đã thử bắt đầu nó như một quản trị viên? Bắt đầu Visual Studio với tư cách quản trị viên nếu bạn sử dụng nó, bởi vì làm việc với .batcác tệp yêu cầu các đặc quyền đó.

Tôi muốn một cái gì đó có thể sử dụng trực tiếp hơn mà không cần các giá trị chuỗi mã hóa cụ thể của tổ chức trong đó. Tôi cung cấp sau đây như một đoạn mã có thể tái sử dụng trực tiếp. Nhược điểm nhỏ là cần xác định và chuyển thư mục làm việc khi thực hiện cuộc gọi.

public static void ExecuteCommand(string command, string workingFolder)
        {
            int ExitCode;
            ProcessStartInfo ProcessInfo;
            Process process;

            ProcessInfo = new ProcessStartInfo("cmd.exe", "/c " + command);
            ProcessInfo.CreateNoWindow = true;
            ProcessInfo.UseShellExecute = false;
            ProcessInfo.WorkingDirectory = workingFolder;
            // *** Redirect the output ***
            ProcessInfo.RedirectStandardError = true;
            ProcessInfo.RedirectStandardOutput = true;

            process = Process.Start(ProcessInfo);
            process.WaitForExit();

            // *** Read the streams ***
            string output = process.StandardOutput.ReadToEnd();
            string error = process.StandardError.ReadToEnd();

            ExitCode = process.ExitCode;

            MessageBox.Show("output>>" + (String.IsNullOrEmpty(output) ? "(none)" : output));
            MessageBox.Show("error>>" + (String.IsNullOrEmpty(error) ? "(none)" : error));
            MessageBox.Show("ExitCode: " + ExitCode.ToString(), "ExecuteCommand");
            process.Close();
        }

Được gọi như thế này:

    // This will get the current WORKING directory (i.e. \bin\Debug)
    string workingDirectory = Environment.CurrentDirectory;
    // This will get the current PROJECT directory
    string projectDirectory = Directory.GetParent(workingDirectory).Parent.FullName;
    string commandToExecute = Path.Combine(projectDirectory, "TestSetup", "WreckersTestSetupQA.bat");
    string workingFolder = Path.GetDirectoryName(commandToExecute);
    commandToExecute = QuotesAround(commandToExecute);
    ExecuteCommand(commandToExecute, workingFolder);

Trong ví dụ này, từ bên trong Visual Studio 2017, là một phần của quá trình chạy thử, tôi muốn chạy tệp bó thiết lập lại môi trường trước khi thực hiện một số thử nghiệm. (SpecFlow + xUnit). Tôi cảm thấy mệt mỏi với các bước bổ sung để tự chạy riêng tập tin bat và muốn chạy tập tin bat như một phần của mã thiết lập thử nghiệm C #. Tệp bó thiết lập lại môi trường di chuyển các tệp trường hợp kiểm tra trở lại thư mục đầu vào, dọn sạch các thư mục đầu ra, v.v. để đến trạng thái bắt đầu kiểm tra thích hợp để kiểm tra. Phương thức Báo giá đơn giản chỉ cần đặt dấu ngoặc kép xung quanh dòng lệnh trong trường hợp có khoảng trắng trong tên thư mục ("Tệp chương trình", có ai không?). Tất cả những gì có trong đó là: chuỗi riêng tư Báo giá chuỗi (đầu vào chuỗi) {return "\" "+ input +" \ "";}

Hy vọng một số tìm thấy điều này hữu ích và tiết kiệm một vài phút nếu kịch bản của bạn tương tự như của tôi.

Với các giải pháp được đề xuất trước đây, tôi đã đấu tranh để có nhiều lệnh npm được thực thi trong một vòng lặp và nhận tất cả các kết quả đầu ra trên cửa sổ giao diện điều khiển.

Cuối cùng nó đã bắt đầu hoạt động sau khi tôi kết hợp mọi thứ từ các bình luận trước đó, nhưng sắp xếp lại luồng thực thi mã.

Điều tôi nhận thấy là đăng ký sự kiện đã được thực hiện quá muộn (sau khi quá trình đã bắt đầu) và do đó một số kết quả đầu ra không được nắm bắt.

Các mã dưới đây bây giờ làm như sau:

1. Đăng ký vào các sự kiện, trước khi quá trình bắt đầu, do đó đảm bảo rằng không có đầu ra nào bị bỏ lỡ.
2. Bắt đầu đọc từ đầu ra ngay khi quá trình được bắt đầu.

Mã đã được kiểm tra chống lại các bế tắc, mặc dù nó là đồng bộ (thực thi một quy trình tại thời điểm đó) vì vậy tôi không thể đảm bảo điều gì sẽ xảy ra nếu điều này được chạy song song.

    static void RunCommand(string command, string workingDirectory)
    {
        Process process = new Process
        {
            StartInfo = new ProcessStartInfo("cmd.exe", $"/c {command}")
            {
                WorkingDirectory = workingDirectory,
                CreateNoWindow = true,
                UseShellExecute = false,
                RedirectStandardError = true,
                RedirectStandardOutput = true
            }
        };

        process.OutputDataReceived += (object sender, DataReceivedEventArgs e) => Console.WriteLine("output :: " + e.Data);

        process.ErrorDataReceived += (object sender, DataReceivedEventArgs e) => Console.WriteLine("error :: " + e.Data);

        process.Start();
        process.BeginOutputReadLine();
        process.BeginErrorReadLine();
        process.WaitForExit();

        Console.WriteLine("ExitCode: {0}", process.ExitCode);
        process.Close();
    }

Sử dụng CliWrap :

var result = await Cli.Wrap("foobar.bat").ExecuteBufferedAsync();

var exitCode = result.ExitCode;
var stdOut = result.StandardOutput;

System.Diagnostics.Process.Start(BatchFileName, Parameters);

Tôi biết điều này sẽ làm việc cho tệp bó và tham số, nhưng không biết làm thế nào để có kết quả trong C #. Thông thường, các đầu ra được xác định trong tệp bó.