How to get BitmapImage into UI thread via Dispatcher.BeginInvoke?

Question

How to get BitmapImage into UI thread via Dispatcher.BeginInvoke?

WoodManEXP 150

Hi,

Can you help me understand why a C# call to Dispatcher.BeginInvoke is throwing this exception:

System.Reflection.TargetParameterCountException: 'Parameter count mismatch.

The code snippet, initially lifted from a GitHub project, looks like this

    // Get BitmapImage from OpenCVSharp webcam capture
	var converted = Convert(BitmapConverter.ToBitmap(matImage));

	// Throw this to UI thread to update the <Image> element
	UI_Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action<BitmapImage>((converted) =>
	{
	    imgViewport.Source = converted; // converted;
	}));

The bitmap is being processed/augmented by a long-running process on another thread, don’t want to be doing that on the UI thread, and when that process completes the app intends to update the <Image> element with the processed bitmap.

Whenever BeginInvoke is called the Parmeter count mismatch exception is thrown. I’ve researched this quite a bit and tried several ways to correct. Can anyone help me understand how to get the bitmap into the UI thread?

TY!

0 comments

Answer accepted by question author

0 additional answers

Your answer

Answer 1

Hi @WoodManEXP ,

Thanks for sharing the code snippet.

The exception comes from the delegate type. new Action<BitmapImage>(...) expects one argument, but the BeginInvoke overload you're calling doesn't pass any, so WPF complains about the parameter count. Your lambda parameter is also named converted, which hides the variable you actually want to use.

Switch to a plain Action and let the lambda capture the bitmap:

BitmapImage converted = Convert(BitmapConverter.ToBitmap(matImage));
if (converted.CanFreeze) converted.Freeze();
 
imgViewport.Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(() =>
{
    imgViewport.Source = converted;
}));

Please don't skip the Freeze() call. A BitmapImage created on a background thread can't be used on the UI thread unless it's frozen. Without it, you'll fix this error and then hit a "different thread owns it" exception right after. If your Convert method loads the image from a stream, also set CacheOption = BitmapCacheOption.OnLoad before EndInit(). Otherwise Freeze() may fail.

If you found my response helpful or informative, I would greatly appreciate it if you could follow this guide for your confirmation.

Thank you.

WoodManEXP 150 Reputation points

2026-11-10T13:14:19.45+00:00

Really helpful. TY!!

Answer 2

Replace the parameterized Action<BitmapImage> with a parameterless Action that captures converted, and freeze the background-created image before dispatching it to the UI thread.

// Runs on the background thread.
BitmapImage converted = Convert(BitmapConverter.ToBitmap(matImage));

if (converted.CanFreeze)
    converted.Freeze();

imgViewport.Dispatcher.BeginInvoke(
    DispatcherPriority.Normal,
    new Action(() =>
    {
        imgViewport.Source = converted;
    }));

Why the exception occurs

Your delegate declares one required parameter:

new Action<BitmapImage>((converted) => { ... })

However, the selected BeginInvoke(DispatcherPriority, Delegate) overload supplies no arguments to that delegate. Consequently, invocation expects one parameter but receives zero, producing TargetParameterCountException. That exception specifically indicates that the invocation's supplied parameter count differs from the delegate's expected count.^1^

The captured-variable version uses an Action with zero parameters, matching that overload. BeginInvoke then queues the UI update asynchronously on the dispatcher's thread.^2^

Using imgViewport.Dispatcher also ensures that the dispatcher belongs to the UI element being updated.

Alternative: pass the bitmap as an explicit argument

If a parameterized delegate is preferable, use the overload that accepts an argument:

if (converted.CanFreeze)
    converted.Freeze();

imgViewport.Dispatcher.BeginInvoke(
    DispatcherPriority.Normal,
    new Action<BitmapImage>(bitmap =>
    {
        imgViewport.Source = bitmap;
    }),
    converted);

Here, converted is explicitly supplied as the argument for the delegate's bitmap parameter. Do not name the lambda parameter converted when an outer variable has the same name; although legal in some contexts, it obscures which value is being used.

Cross-thread image ownership

Fixing the parameter count does not by itself make an image created on a worker thread transferable. WPF UI objects have thread affinity, and BitmapImage participates in WPF's Freezable model. An unfrozen Freezable cannot be shared across threads; a frozen one can.^3^

Therefore:

Complete the conversion and all image modifications on the worker thread.
Check CanFreeze and call Freeze() there.
Dispatch only the short imgViewport.Source assignment.
Do not modify the image after freezing it.

If CanFreeze is false, create or copy the WPF image on the UI thread instead, while leaving the expensive OpenCV processing on the worker thread. The Image.Source property accepts an ImageSource, including a BitmapImage.^4^

References