Windows Forms enforces strict thread affinity: UI elements can only be modified by the thread that created them. Attempting to update a control from a worker thread triggers an InvalidOperationException. While setting Control.CheckForIllegalCrossThreadCalls to false suppresses the check at compile time, it bypasses synchronization primitives and frequently leads to deadlocks or corrupted rendering states. Therefore, explicit thread marshaling is required.

The standard approach relies on the InvokeRequired property. When true, the current context differs from the owning thread, necessitating a marshal operation via Invoke or BeginInvoke. This guarantees execution on the UI thread's message loop.

Approach 1: Pre-defined Delegates Declaring strongly typed delegates allows clear separation between data processing and UI marshaling.

public partial class MainForm : Form
{
    private readonly Action<byte[]> _updateDisplayDelegate;

    public MainForm()
    {
        InitializeComponent();
        // Initialize delegate reference during construction
        _updateDisplayDelegate = ProcessDataOnUiThread;
    }

    private void UpdateControlWithHex(byte[] dataBuffer)
    {
        if (displayPanel.InvokeRequired)
        {
            // Marshal the call back to the creator thread
            displayPanel.Invoke(_updateDisplayDelegate, dataBuffer);
        }
        else
        {
            // Execute on the correct thread
            displayPanel.AppendText(ConvertBytesToHex(dataBuffer) + "\r\n");
        }
    }

    private void Port_DataReceived(object sender, SerialDataReceivedEventArgs e)
    {
        // Simulate asynchronous hardware event
        int bytesRead = ((SerialPort)sender).BytesToRead;
        byte[] buffer = new byte[bytesRead];
        ((SerialPort)sender).Read(buffer, 0, bytesRead);
        
        // Trigger thread-safe update
        UpdateControlWithHex(buffer);
    }

    private void ProcessDataOnUiThread(byte[] inputData)
    {
        UpdateControlWithHex(inputData);
    }
}

Approach 2: Inline Lambdas and MethodInvoker Avoiding external delegate declarations simplifies the codebase. You can construct the invoctaion payload directly within the method body.

private void HandleIncomingPayload(byte[] rawData)
{
    if (statusLabel.InvokeRequired)
    {
        statusLabel.Invoke(new MethodInvoker(() => HandleIncomingPayload(rawData)));
    }
    else
    {
        statusLabel.Text += $"Decoded: {Encoding.UTF8.GetString(rawData)}";
    }
}

Direct synchronous marshaling can also be performed inline with out auxiliary methods:

// Captured context executes on the UI thread
Invoke((Action)(() => 
{
    logTextBox.Clear();
    logTextBox.AppendText(BuildMessageString());
}));

Each technique routes execution through the underlying Windows message pump, ensuring thread safety while maintaining responsive interfaces during long-running operations or blocking I/O waits.