[c#] 종료를 기다리는 동안 프로세스가 때때로 정지됨

관련 게시물에서 허용되는 답변 을 요약 해 보겠습니다 .

문제는 StandardOutput 및 / 또는 StandardError를 리디렉션하면 내부 버퍼가 가득 찰 수 있다는 것입니다. 어떤 주문을 사용하든 문제가있을 수 있습니다.

• StandardOutput을 읽기 전에 프로세스가 종료 될 때까지 기다리면 프로세스가 쓰기를 차단할 수 있으므로 프로세스가 종료되지 않습니다.
• ReadToEnd를 사용하여 StandardOutput에서 읽는 경우 프로세스가 StandardOutput을 닫지 않는 경우 (예 : 종료되지 않거나 StandardError에 대한 쓰기가 차단 된 경우) 프로세스가 차단 될 수 있습니다.

그러나 수용 된 답변조차도 특정 경우의 집행 순서와 어려움을 겪습니다.

편집 : 시간 초과가 발생 하면 ObjectDisposedException을 피하는 방법은 아래 답변을 참조하십시오 .

Rx가 실제로 빛나는 여러 가지 이벤트를 조정하려는 상황이 있습니다.

Rx의 .NET 구현은 System.Reactive NuGet 패키지로 제공됩니다.

Rx가 이벤트 작업을 용이하게하는 방법을 알아 보겠습니다.

// Subscribe to OutputData
Observable.FromEventPattern<DataReceivedEventArgs>(process, nameof(Process.OutputDataReceived))
    .Subscribe(
        eventPattern => output.AppendLine(eventPattern.EventArgs.Data),
        exception => error.AppendLine(exception.Message)
    ).DisposeWith(disposables);

FromEventPattern이벤트의 개별 발생을 통합 스트림 (일명 관찰 가능)에 매핑 할 수 있습니다. 이를 통해 파이프 라인에서 이벤트를 처리 할 수 ​​있습니다 (LINQ와 같은 의미 체계 사용). Subscribe여기에 사용 과부하가 제공된다 Action<EventPattern<...>>하고 Action<Exception>. 관찰 된 이벤트가 발생할 때마다 그 sender와는 args래핑됩니다 EventPattern과를 통해 밀어 Action<EventPattern<...>>. 파이프 라인에서 예외가 발생하면 Action<Exception>이 사용됩니다.

의 단점 중 하나 Event이 유스 케이스 (및 참조 된 게시물의 모든 해결 방법에서)에 명확하게 설명 된 패턴 이벤트 핸들러를 언제 / 구독 취소해야하는지 명확하지 않다는 것입니다.

Rx를 IDisposable사용하면 구독을 할 때 다시 돌아옵니다 . 폐기 할 때 구독을 효과적으로 종료합니다. 의 추가로 DisposeWith(에서 차용 확장 메서드 RxUI ), 우리는 여러 추가 할 수 있습니다 IDisposableA와 S를 CompositeDisposable(이름을 disposables코드 샘플에서). 모두 완료되면 한 번의 호출로 모든 구독을 종료 할 수 있습니다disposables.Dispose() .

확실히, Rx로 할 수있는 것은 아무것도 없으며, 바닐라 .NET으로는 할 수 없습니다. 기능적인 사고 방식에 적응하면 결과 코드는 추론하기가 훨씬 쉽습니다.

public static void ExecuteScriptRx(string path, int processTimeOutMilliseconds, out string logs, out bool success, params string[] args)
{
    StringBuilder output = new StringBuilder();
    StringBuilder error = new StringBuilder();

    using (var process = new Process())
    using (var disposables = new CompositeDisposable())
    {
        process.StartInfo = new ProcessStartInfo
        {
            WindowStyle = ProcessWindowStyle.Hidden,
            FileName = "powershell.exe",
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            UseShellExecute = false,
            Arguments = $"-ExecutionPolicy Bypass -File \"{path}\"",
            WorkingDirectory = Path.GetDirectoryName(path)
        };

        if (args.Length > 0)
        {
            var arguments = string.Join(" ", args.Select(x => $"\"{x}\""));
            process.StartInfo.Arguments += $" {arguments}";
        }

        output.AppendLine($"args:'{process.StartInfo.Arguments}'");

        // Raise the Process.Exited event when the process terminates.
        process.EnableRaisingEvents = true;

        // Subscribe to OutputData
        Observable.FromEventPattern<DataReceivedEventArgs>(process, nameof(Process.OutputDataReceived))
            .Subscribe(
                eventPattern => output.AppendLine(eventPattern.EventArgs.Data),
                exception => error.AppendLine(exception.Message)
            ).DisposeWith(disposables);

        // Subscribe to ErrorData
        Observable.FromEventPattern<DataReceivedEventArgs>(process, nameof(Process.ErrorDataReceived))
            .Subscribe(
                eventPattern => error.AppendLine(eventPattern.EventArgs.Data),
                exception => error.AppendLine(exception.Message)
            ).DisposeWith(disposables);

        var processExited =
            // Observable will tick when the process has gracefully exited.
            Observable.FromEventPattern<EventArgs>(process, nameof(Process.Exited))
                // First two lines to tick true when the process has gracefully exited and false when it has timed out.
                .Select(_ => true)
                .Timeout(TimeSpan.FromMilliseconds(processTimeOutMilliseconds), Observable.Return(false))
                // Force termination when the process timed out
                .Do(exitedSuccessfully => { if (!exitedSuccessfully) { try { process.Kill(); } catch {} } } );

        // Subscribe to the Process.Exited event.
        processExited
            .Subscribe()
            .DisposeWith(disposables);

        // Start process(ing)
        process.Start();

        process.BeginOutputReadLine();
        process.BeginErrorReadLine();

        // Wait for the process to terminate (gracefully or forced)
        processExited.Take(1).Wait();

        logs = output + Environment.NewLine + error;
        success = process.ExitCode == 0;
    }
}

우리는 이벤트를 옵저버 블에 매핑하는 첫 번째 부분에 대해 이미 논의 했으므로 고기 부분으로 바로 이동할 수 있습니다. 여기에 Observable을processExited 변수를 두 번 이상 사용하려고하기 때문에 변수에 .

먼저을 호출하여 활성화합니다 Subscribe. 그리고 나중에 우리가 첫 번째 가치를 ‘기다리고 싶어’.

var processExited =
    // Observable will tick when the process has gracefully exited.
    Observable.FromEventPattern<EventArgs>(process, nameof(Process.Exited))
        // First two lines to tick true when the process has gracefully exited and false when it has timed out.
        .Select(_ => true)
        .Timeout(TimeSpan.FromMilliseconds(processTimeOutMilliseconds), Observable.Return(false))
        // Force termination when the process timed out
        .Do(exitedSuccessfully => { if (!exitedSuccessfully) { try { process.Kill(); } catch {} } } );

// Subscribe to the Process.Exited event.
processExited
    .Subscribe()
    .DisposeWith(disposables);

// Start process(ing)
...

// Wait for the process to terminate (gracefully or forced)
processExited.Take(1).Wait();

OP의 문제점 중 하나는 process.WaitForExit(processTimeOutMiliseconds)시간이 초과되면 프로세스가 종료 된다고 가정한다는 것 입니다. 에서 MSDN :

연관된 프로세스가 종료 될 때까지 지정된 밀리 초 동안 프로세스 컴포넌트가 대기하도록 지시합니다 .

대신 시간이 초과되면 제어를 현재 스레드로 되돌립니다 (즉, 블로킹 중지). 프로세스 시간이 초과되면 수동으로 강제 종료해야합니다. 시간 초과가 발생한시기를 알기 위해 Process.Exited이벤트를processExited 처리 관찰 가능 객체에 . 이런 식으로 Do연산자에 대한 입력을 준비 할 수 있습니다 .

코드는 매우 자명하다. exitedSuccessfully프로세스가 정상적으로 종료 된 경우 그렇지 않은 경우 exitedSuccessfully강제 종료해야합니다. 참고 process.Kill()로 비동기 적으로 실행되고, 심판 발언 . 그러나 process.WaitForExit()바로 호출 하면 교착 상태가 다시 발생할 가능성이 열립니다. 따라서 강제 종료의 경우에도 using출력이 중단 / 손상된 것으로 간주 될 수 있으므로 스코프가 종료 될 때 모든 일회용품을 정리하는 것이 좋습니다 .

try catch구조는 사용자가 정렬 한 예외적 인 경우 (웃기려는 의도 없음) 예약되어 processTimeOutMilliseconds프로세스가 완료에 필요한 실제 시간. 즉, Process.Exited이벤트와 타이머 사이에 경쟁 조건이 발생합니다 . 이런 일이 일어날 가능성은 비동기 특성으로 인해 다시 확대됩니다 process.Kill(). 테스트하는 동안 한 번 발생했습니다.

완전성을 위해 DisposeWith확장 방법.

/// <summary>
/// Extension methods associated with the IDisposable interface.
/// </summary>
public static class DisposableExtensions
{
    /// <summary>
    /// Ensures the provided disposable is disposed with the specified <see cref="CompositeDisposable"/>.
    /// </summary>
    public static T DisposeWith<T>(this T item, CompositeDisposable compositeDisposable)
        where T : IDisposable
    {
        if (compositeDisposable == null)
        {
            throw new ArgumentNullException(nameof(compositeDisposable));
        }

        compositeDisposable.Add(item);
        return item;
    }
}

답변

.
.
.
    process.BeginOutputReadLine();
    process.BeginErrorReadLine();

    //First waiting for ReadOperations to Timeout and then check Process to Timeout
    if (!outputWaitHandle.WaitOne(ProcessTimeOutMiliseconds) && !errorWaitHandle.WaitOne(ProcessTimeOutMiliseconds)
        && !process.WaitForExit(ProcessTimeOutMiliseconds)  )
    {
        //To cancel the Read operation if the process is stil reading after the timeout this will prevent ObjectDisposeException
        process.CancelOutputRead();
        process.CancelErrorRead();

        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine("Timed Out");
        Logs = output + Environment.NewLine + error;
       //To release allocated resource for the Process
        process.Close();
        return  (false, logs);
    }

    Console.ForegroundColor = ConsoleColor.Green;
    Console.WriteLine("Completed On Time");
    Logs = output + Environment.NewLine + error;
    ExitCode = process.ExitCode.ToString();
    // Close frees the memory allocated to the exited process
    process.Close();

    //ExitCode now accessible
    return process.ExitCode == 0 ? (true, logs) : (false, logs);
    }
}
finally{}

public async Task<int> RunProcessAsync(params string[] args)
    {
        try
        {
            var tcs = new TaskCompletionSource<int>();

            var process = new Process
            {
                StartInfo = {
                    FileName = 'file path',
                    RedirectStandardOutput = true,
                    RedirectStandardError = true,
                    Arguments = "shell command",
                    UseShellExecute = false,
                    CreateNoWindow = true
                },
                EnableRaisingEvents = true
            };


            process.Exited += (sender, args) =>
            {
                tcs.SetResult(process.ExitCode);
                process.Dispose();
            };

            process.Start();
            // Use asynchronous read operations on at least one of the streams.
            // Reading both streams synchronously would generate another deadlock.
            process.BeginOutputReadLine();
            string tmpErrorOut = await process.StandardError.ReadToEndAsync();
            //process.WaitForExit();


            return await tcs.Task;
        }
        catch (Exception ee) {
            Console.WriteLine(ee.Message);
        }
        return -1;
    }

if (process.WaitForExit(ProcessTimeOutMiliseconds))
{
  process.WaitForExit();
}