How to write a single line to StandardInputPipe once only?

[El-Gor-do]

I have a test child app that reads from Standard Input and prints whatever was received, something like this:

while (true)
{
    Console.WriteLine(Console.ReadLine());
}

I also have a test parent app that waits for a user to press any key to send a message to the child app's Standard Input. In the parent app, if I run the child app using System.Diagnostics.Process like the code below then the child app correctly prints out test message once only.

ProcessStartInfo startInfo = new ProcessStartInfo("ChildApp.exe")
{
    RedirectStandardInput = true,
};
Process childProcess = new Process()
{
    StartInfo = startInfo,
};
childProcess.Start();

// wait for user to press a key
...
childProcess.StandardInput.WriteLine("test message");

If I replace System.Diagnostics.Process with CliWrap.Command and start the child app like this:

MemoryStream inputStream = new MemoryStream();
StreamWriter inputWriter = new StreamWriter(inputStream);
Command cmd = new Command("ChildApp.exe").WithStandardInputPipe(PipeSource.FromStream(inputStream));
CommandTask<CommandResult> cmdTask = cmd.ExecuteAsync();

// wait for user to press a key
...
inputWriter.WriteLine("test message");

before the parent app reaches inputWriter.WriteLine("test message"); it is already piping empty strings to child app's Standard Input - I can see child app printing out blank lines as quickly as the console is able to. Is this the intended behaviour? How do I write just a single string to the child app's Standard Input? After the string is written, nothing should be piped to child app's Standard Input until the next time the user presses a key.

[Tyrrrz]

If you know the string beforehand, use PipeSource.FromString(...) instead. The memory stream you are creating is empty at the time of running the process, so it just writes nothing.

If you need some sort of live channel, you can also use PipeSource.Create(...):

var source = PipeSource.Create(async (destination, token) =>
{
    await WaitUntilYourDataBecomesAvailableAsync();
    await destination.WriteAsync(...);
});

You could also create your own stream that has explicit completion. The problem with MemoryStream is that it's always considered completed, i.e. ReadAsync(...) returns 0 when it's in the initial state.

[El-Gor-do]

PipeSource.FromString(...) immediately writes the string to Standard Input instead of waiting for a trigger, e.g. user keypress, so it's not quite what I'm looking for. Is there any possibility for Command or CommandTask to expose the underlying Process's StandardInput StreamWriter so that I can write to Standard Input only when I have something to write?

[Tyrrrz]

Yeah, like I said, that can be done via PipeSource.Create(...) (which is just a shorthand for creating your own custom implementation of PipeSource):

var source = PipeSource.Create(async (destination, token) =>
{
    await WaitUntilYourDataBecomesAvailableAsync();
    await destination.WriteAsync(...);
});

In this situation, destination is the StandardInput stream of the process.

The way you would this is by using synchronization primitives to signal to the source that the data is available or that it's finished. A very trivial example would be:

var data = default(byte[]);

var source = PipeSource.Create(async (destination, token) =>
{
    while (data is null)
        await Task.Delay(1000, token);

    await destination.WriteAsync(data);
});

var task = (source | Cli.Wrap(...)).ExecuteAsync();

// ... wait for user to provide data
data = ...;

[El-Gor-do]

How I've ended up doing it is to create my own BlockingPipeSource (not sure if this is the right name) using the AsyncCollection blocking collection from Stephen Cleary's Nito.AsyncEx.Coordination Nuget package:

public class BlockingPipeSource : PipeSource
{
    private AsyncCollection<string> Buffer { get; }

    public BlockingPipeSource()
    {
        this.Buffer = new AsyncCollection<string>();
    }

    public override async Task CopyToAsync(Stream destination, CancellationToken cancellationToken = default)
    {
        while (!cancellationToken.IsCancellationRequested)
        {
            // wait until there is a value to write
            string value = await this.Buffer.TakeAsync(cancellationToken);

            // write value
            using (StreamWriter sw = new StreamWriter(destination, leaveOpen: true))
            {
                await sw.WriteLineAsync(value);
            }
        }
    }

    public void Write(string value)
    {
        this.Buffer.Add(value);
    }

    public async Task WriteAsync(string value, CancellationToken cancellationToken = default)
    {
        await this.Buffer.AddAsync(value, cancellationToken);
    }
}

The usage is

BlockingPipeSource standardInputPipe = new BlockingPipeSource();
Command cmd = new Command("ChildApp.exe").WithStandardInputPipe(standardInputPipe);
CommandTask<CommandResult> cmdTask = cmd.ExecuteAsync();
...
// wait until an event triggers the need to write to ChildApp's StandardInput
await standardInputPipe.WriteAsync("value");

[ehabhussein]

Thank you!