More threading challenges

[axtens]

Getting back to the previous posting about capturing StdOut, I've got things going to the point where I can have stdout/stderr being either buffered and then displayed or pushed to RichEditBoxes [REBs] while the process that is putting stuff in stdout/stderr is running. But is that what is happening? It appears not.

So first up I get a ref to the current thread.

DispatcherQueue dispatcher = Microsoft.UI.Dispatching.DispatcherQueue.GetForCurrentThread();

I pass that in to the method that runs the external process, viz

        public (string StdOut, string StdErr) RunPeloton2(string args, string buff, long quietude, DispatcherQueue dispatcher)
        {
            string? Exe = ApplicationData.Current.LocalSettings.Values["Interpreter.P3"].ToString();

            ProcessStartInfo info = new()
            {
                Arguments = $"{args}",
                FileName = Exe,
                UseShellExecute = false,
                RedirectStandardOutput = true,
                RedirectStandardError = true,
                RedirectStandardInput = true,
                CreateNoWindow = true,
                WindowStyle = ProcessWindowStyle.Hidden
            };

            var proc = Process.Start(info);
            StringBuilder stdout = new();
            StringBuilder stderr = new();

            StreamWriter stream = proc.StandardInput;
            stream.Write(buff);
            stream.Close();

            proc.OutputDataReceived += async (object sender, DataReceivedEventArgs e) =>
            {
                if (quietude == 0)
                {
                    stdout.AppendLine(e.Data);
                }
                else
                {
                    await Task.Run(async () => { dispatcher.TryEnqueue(() => { AddOutput(e.Data!); }); });
                }
            };
            proc.ErrorDataReceived += async (object sender, DataReceivedEventArgs e) =>
            {
                if (quietude == 0)
                {
                    stderr.AppendLine(e.Data);
                }
                else
                {
                    await Task.Run(async () => { dispatcher.TryEnqueue(() => { AddError(e.Data!); }); });
                }
            };

            proc.BeginErrorReadLine();
            proc.BeginOutputReadLine();

            proc.WaitForExit();
            proc.Dispose();

            return (StdOut: stdout.ToString().Trim(), StdErr: stderr.ToString().Trim());
        }

(quietude controls whether the output is buffered or put into the REBs.)

AddError and AddOutput and their helper method are defined as

        public void AddOutput(string text)
        {
            AddInsertParagraph(outputText, text, true, false);
        }

        public void AddError(string text)
        {
            AddInsertParagraph(errorText, text, true, false);
        }

        private static void AddInsertParagraph(RichEditBox reb, string text, bool addInsert = true, bool withPrefix = true)
        {
            if (string.IsNullOrEmpty(text))
            {
                return;
            }
            const string stamp = "> ";
            if (withPrefix)
                text = text.Insert(0, stamp);

            reb.IsReadOnly = false;
            reb.Document.GetText(Microsoft.UI.Text.TextGetOptions.UseLf, out string? t);
            if (addInsert)
            {
                reb.Document.SetText(Microsoft.UI.Text.TextSetOptions.None, t + "\n" + text);
            }
            else
            {
                reb.Document.SetText(Microsoft.UI.Text.TextSetOptions.None, text + "\n" + t);
            }
            reb.IsReadOnly = true;
        }

(I thought I saw in the documentation that one could write to the REBs even when .IsReadOnly was true but actually one gets a 0x80070005 - Attempted to perform an unauthorized operation, when writing to a read-only REB, thus the false-ing and true-ing.)

When I run this code the REBs fill only after the script has completed. It seems that the enqueuing is doing just that -- enqueuing -- and then waiting around until it's got some good reason to run the items in the queue.

What's going on here? Is it that I don't understand threading (very likely)?

The other thing I'm noticing is that the enqueued tasks don't run in any particular order, so the 23rd line in the output doesn't necessarily appear in the REB after the 22nd and before the 24th.

Back in the day, the process would run in a CMD window and send its output to the CMD window's stdout and not be captured. Instead the called program would create .out and .err files and these would be loaded into the REBs. So now we're trying to replicate that behaviour ... without much success.

ONE HOUR LATER

The REBs are being updated. But they're not actually showing the data. And no equivalent for Google Apps Script's SpreadsheetApp.flush() seems to exist