Das Ausführen der ausführbaren Datei über die Befehlszeile ist in Ordnung, aber das Ausführen über ein anderes Programm führt dazu, dass es nicht reagiert

Frageninhalt

Führen Sie einfach die ausführbare Datei und die Parameter in der Windows-Eingabeaufforderung aus:

cgx_STATIC.exe -b C:\Users\m3\AppData\Local\Temp\shot-277325955.fbd

Wenn jedoch dieselbe ausführbare Datei über Golang ausgeführt wird, reagiert die ausführbare Datei nicht mehr, nachdem die ausführbare Datei einige Ausgabedateien erstellt hat.

<code>
// Run an executable and print its log into a file.
func RunWithLogFile(pthExe string, arg []string, fLog *os.File) error {
    cmd := exec.Command(pthExe, arg...)

    stdout, err := cmd.StdoutPipe()
    if err != nil {
        return err
    }
    stderr, err := cmd.StderrPipe()
    if err != nil {
        return err
    }

    err = cmd.Start()
    if err != nil {
        return err
    }

    // Stream logs:
    // https://stackoverflow.com/a/48849811/3405291
    scannerOut := bufio.NewScanner(stdout)
    scannerErr := bufio.NewScanner(stderr)
    scannerOut.Split(bufio.ScanRunes)
    scannerErr.Split(bufio.ScanRunes)
    for scannerOut.Scan() {
        _, err = fLog.WriteString(scannerOut.Text())
        if err != nil {
            return err
        }
    }
    for scannerErr.Scan() {
        _, err = fLog.WriteString(scannerErr.Text())
        if err != nil {
            return err
        }
    }
    if scannerOut.Err() != nil {
        return err
    }
    if scannerErr.Err() != nil {
        return err
    }

    err = cmd.Wait()
    return err
}
</code>

Ich frage mich, ob der obige Go-Code einen Fehler enthält oder ob er nicht zum Ausführen einer ausführbaren Datei geeignet ist?

Einzelne Goroutine

Dem Vorschlag von @BurakSerdar folgend, habe ich von stdout und stderr in separaten Goroutinen gelesen, aber das Problem wurde nicht gelöst:

<code>
// Run an executable and print its log into a file.
func RunWithLogFile(pthExe string, arg []string, fLog *os.File) error {
    cmd := exec.Command(pthExe, arg...)

    stdout, err := cmd.StdoutPipe()
    if err != nil {
        return err
    }
    stderr, err := cmd.StderrPipe()
    if err != nil {
        return err
    }

    var wg sync.WaitGroup
    wg.Add(2)

    go streamToLogFile(stdout, fLog, &wg)
    go streamToLogFile(stderr, fLog, &wg)

    err = cmd.Start()
    if err != nil {
        return err
    }

    wg.Wait()

    err = cmd.Wait()
    return err
}

func streamToLogFile(output io.ReadCloser, fLog *os.File, wg *sync.WaitGroup) {
    defer wg.Done()
    scanner := bufio.NewScanner(output)
    scanner.Split(bufio.ScanRunes)
    for scanner.Scan() {
        _, err := fLog.WriteString(scanner.Text())
        if err != nil {
            log.Printf("error: write to log file: %s", err.Error())
        }
    }
    err := scanner.Err()
    if err != nil {
        log.Printf("error: write to log file: %s", err.Error())
    }
}
</code>

Richtige Antwort

Das Problem der fehlenden Reaktion wurde gelöst, indem die ausführbare Datei mit Administratorberechtigungenausgeführt wurde. Ich mache das:

A C# code runs a Go code and the Go code runs a C Code, i.e. external executable.

C-ausführbare Datei ruft einige OpenGL GLUT-Aufrufe auf. Möglicherweise benötigen sie

Administratorrechte.

Das Starten des Go-Codes über C# löst dieses Problem wie folgt:

https://www.php.cn/link/ac90e5f00f7542d99231f63fb0dfeecf< /a>

<code>        public static void RunLogic(string exePath, string args, PostProcess pp)
        {
            cmd = new Process();

            try
            {
                cmd.StartInfo.FileName = exePath;
                cmd.StartInfo.Arguments = args;
                cmd.StartInfo.UseShellExecute = true;
                cmd.StartInfo.CreateNoWindow = false;
                cmd.StartInfo.RedirectStandardOutput = false;
                cmd.StartInfo.RedirectStandardError = false;
                cmd.StartInfo.RedirectStandardInput = false;
                // Vista or higher check.
                // https://www.php.cn/link/ac90e5f00f7542d99231f63fb0dfeecf
                if (System.Environment.OSVersion.Version.Major >= 6)
                {
                    // Run with admin privileges to avoid a non-responsive executable.
                    cmd.StartInfo.Verb = "runas";
                }
                cmd.EnableRaisingEvents = true;
                cmd.Exited += new EventHandler(cmd_Exited);
                cmd.Exited += new EventHandler(pp);

                cmd.Start();
            }

            catch (Exception ex)
            {
                RhinoApp.WriteLine("Error on process start: {0}", ex.Message);
            }
        }
</code>

Das obige ist der detaillierte Inhalt vonDas Ausführen der ausführbaren Datei über die Befehlszeile ist in Ordnung, aber das Ausführen über ein anderes Programm führt dazu, dass es nicht reagiert. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!