使用控制台应用程序.NET Core在并行C＃中运行两个dotnet进程

Question

I have a project with three consoles. One console will open in parallel other two processes to do some jobs (independently).

All consoles are using dotnet core framework.

MultipleConsoleWindows is main application which looks like:

static void Main(string[] args)
{
    Task t1 = new Task(async () => { await ProcessManager.StartAsync("c1"); });
    Task t2 = new Task(async () => { await ProcessManager.StartAsync("c2"); });

    // what should do here ?

    Console.WriteLine("done");
    Console.Read();
}

and ProcessManager class:

public static class ProcessManager
{
    const string C1 = @"pathTo\ConsoleNumberOne.dll";
    const string C2 = @"pathTo\ConsoleNumberTwo.dll";

    public static async Task<string> StartAsync(string type)
    {
        Console.WriteLine($"Start {type}");

        var proc = type.Equals("c1") ? C1 : C2;
        return await Task.Run(() => StartProcess(proc));
    }

    static string StartProcess(string proc)
    {
        ProcessStartInfo procStartInfo = new ProcessStartInfo();
        procStartInfo.FileName = "dotnet";
        procStartInfo.Arguments = $"\"{proc}\"";
        procStartInfo.WorkingDirectory = Path.GetDirectoryName(proc);

        procStartInfo.UseShellExecute = false;
        procStartInfo.CreateNoWindow = true;

        procStartInfo.RedirectStandardOutput = true;
        procStartInfo.RedirectStandardError = true;

        int output = 0;

        StringBuilder sb = new StringBuilder();
        using (Process pr = new Process())
        {
            pr.StartInfo = procStartInfo;

            pr.OutputDataReceived += (s, ev) =>
            {
                if (string.IsNullOrWhiteSpace(ev.Data))
                {
                    return;
                }

                sb.AppendLine(ev.Data);

                string[] split = ev.Data.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
                int.TryParse(split[split.Length - 1], out output);
            };

            pr.ErrorDataReceived += (s, err) =>
            {
                if (!string.IsNullOrWhiteSpace(err.Data))
                {
                    sb.AppendLine(err.Data);

                    output = 0;
                }
            };

            pr.EnableRaisingEvents = true;
            pr.Start();
            pr.BeginOutputReadLine();
            pr.BeginErrorReadLine();

            pr.WaitForExit();

            return sb.ToString();
        }
    }
}

The ConsoleNumberOne and ConsoleNumberTwo look similar

static void Main(string[] args)
{
    Console.WriteLine("Hello World!");
    Thread.Sleep(10000);
}

and

static void Main(string[] args)
{
     Console.WriteLine("Hello World!");
     Thread.Sleep(5000);
}

I'm trying to open two consoles in same time which do own job.

How to achieve that in MultipleConsoleWindows side ?

Answer 1

Maebe this can do the trick

static void Main(string[] args)
{
    Action t1 = new Action(async () => { await ProcessManager.StartAsync("c1"); });
    Action t2 = new Action(async () => { await ProcessManager.StartAsync("c2"); });
    Parallel.Invoke(t1, t2);

    Console.WriteLine("done");
    Console.Read();
}

Answer 2

There's no need to use Task.Run to start a child process. Instead of using WaitForExit(); to block until the process exits, the documentation suggests :

To avoid blocking the current thread, use the Exited event.

Before tasks, events were one of the methods of executing jobs asynchronously and receiving notifications. This is called the Event-Based Asynchronous Pattern . Events can be converted to Tasks using a TaskCompletionSource. This is described in How to: Wrap EAP Patterns in a Task .

The example is a bit more verbose than it should. In this case, convertint Exited to a Task is straightforward :

static Task<string> StartProcess(string proc)
{

        StringBuilder sb = new StringBuilder();
        Process pr = new Process
        {
            StartInfo = procStartInfo
        };

        var tcs = new TaskCompletionSource<string>();

        pr.Exited += (o, e) =>
        {
            tcs.SetResult(sb.ToString());
            pr.Dispose();
        };

        ....

        return tcs.Task;
}

Multiple processes can be started and awaited this way :

static async Task Main(string[] args)
{
    var p1 = StartProcess("--version");
    var p2 = StartProcess("--list-runtimes");

    string[] responses=await Task.WhenAll(p1, p2);

    ...
}

TaskCompletionSource.SetResult completes the task returned by the tcs and sets its result, in this case a string. SetException can be used to set the task to the faulted state, raising an exception when awaited. This could be used for example to cancel awaiting if any of the processes returned a non-zero exit code