lock parent thread with message dialog in background thread

The main point is: RunWorkerAsync() starts the background work; it does not wait for it to finish. If you want to show a message after the work is completed, use the RunWorkerCompleted event.

Simple understanding

Think of BackgroundWorker like this:

UI Thread
   |
   | RunWorkerAsync()
   |-------------------------> Background Thread
   |                              |
   |                              | DoWork()
   |                              | Complete task
   |                              |
   |<-----------------------------|
   | RunWorkerCompleted()
   |
   | MessageBox.Show()

RunWorkerAsync() returns immediately, so this:

_backgroundWorker.RunWorkerAsync();

MessageBox.Show("Completed");

does not mean "wait and then show the message."

It means:

Start background work
Immediately show message

Correct solution

Use RunWorkerCompleted:

private void Temp_Load(object? sender, EventArgs e)
{
    complete = false;

    _backgroundWorker.DoWork += backgroundWorker_DoWork;
    _backgroundWorker.RunWorkerCompleted += backgroundWorker_RunWorkerCompleted;

    _backgroundWorker.RunWorkerAsync();
}

private void backgroundWorker_DoWork(object? sender, DoWorkEventArgs e)
{
    // Long-running work here
    // Example:
    // DoSomething();

    complete = true;
}

private void backgroundWorker_RunWorkerCompleted(
    object? sender,
    RunWorkerCompletedEventArgs e)
{
    if (e.Error != null)
    {
        MessageBox.Show("Error: " + e.Error.Message);
        return;
    }

    if (e.Cancelled)
    {
        MessageBox.Show("Operation cancelled.");
        return;
    }

    MessageBox.Show("Task completed successfully.");
}

Why RunWorkerCompleted is important

DoWork runs on a background thread.

private void backgroundWorker_DoWork(object? sender, DoWorkEventArgs e)
{
    // Background thread
}

But RunWorkerCompleted is called after DoWork finishes and, in a normal WinForms application, executes on the UI thread.

private void backgroundWorker_RunWorkerCompleted(...)
{
    MessageBox.Show("Task completed.");
}

Therefore, you don't need to manually "lock the parent thread."

What about MessageBox.Show() inside DoWork?

You can technically do this:

private void backgroundWorker_DoWork(object? sender, DoWorkEventArgs e)
{
    // Background thread

    MessageBox.Show("Completed");
}

But this displays the message from the background thread. It does not block/wait the UI thread.

The UI thread remains available while the background thread is showing the message.

If your requirement is:

"Start the background task, wait until it finishes, then show a completion message on the UI."

Then RunWorkerCompleted is the intended BackgroundWorker pattern.

What happens with your original code?

Your code:

private void Temp_Load(object? sender, EventArgs e)
{
    complete = false;

    _backgroundWorker.RunWorkerAsync();

    MessageBox.Show("lock main ui thread");
}

works approximately like:

UI Thread
   |
   | RunWorkerAsync()
   |       |
   |       +----> DoWork starts
   |
   +----> MessageBox.Show()

The UI thread does not wait for DoWork.

That's why checking:

complete = true;

immediately after RunWorkerAsync() won't work reliably.

For example:

_backgroundWorker.RunWorkerAsync();

if (complete)
{
    MessageBox.Show("Completed");
}

The result may still be:

complete = false

because the background operation hasn't finished yet.

Fresher-friendly rule to remember

So the simple pattern is:

RunWorkerAsync()
       ↓
DoWork
       ↓
Long-running operation
       ↓
RunWorkerCompleted
       ↓
MessageBox.Show()

Don't try to make RunWorkerAsync() wait. Its purpose is specifically to start asynchronous/background work. Use RunWorkerCompleted to continue the UI flow after the work has finished.

I assume that parent thread is also the main ui thread.

I do not understand what you mean by lock the parent thread.

I will assume that the fundamental requirement is to show a message. The BackgroundWorker class is designed to make things easy. You know that RunWorkerAsync causes DoWork to execute in the other thread. If you just want to do something in the window, such as show a completion messge, then do that in the BackgroundWorker.RunWorkerCompleted event handler. The technical details of execution in the UI thread is done for us, you can update a control, such as a text box, the same way that you update controls in other event handlers for the window .