[Extension] Set control properties across threads

[NickThissen]

[C# version here]


Updated: includes methods and functions now as well.


Update:
ForumAccount suggested that the code can be used for any type that implements ISynchronizeInvoke, not just Controls, see here. Since I don't have time to update all this code right now, if you need this change you can just change every Control reference to ISynchronizeInvoke instead.

-------

Hi,

Usually if you want to set a property of a control from another thread you will get an invalid cross-thread operation exception. To solve this you need to invoke a delegate on the same thread, which usually goes like this:

Private Delegate Sub SetLabelTextDelegate(ByVal text As String)
 
    Private Sub SetLabelText(ByVal text As String)
        If Label1.InvokeRequired Then
            Label1.Invoke(New SetLabelTextDelegate(AddressOf SetLabelText), text)
        Else
            Label1.Text = text
        End If
    End Sub

This works fine, but the problem is that it's kind of 'wordy' and can get really annoying to type if you need it for many properties and controls.

I thought I could come up with a quicker solution and I managed to create two extension methods (on Control) to get and set a property safely across threads:

Option Strict On
Option Infer On
 
Imports System.Linq.Expressions
Imports System.Reflection
Imports System.Runtime.CompilerServices
 
Module Extensions
 
    Private Delegate Sub SetThreadSafePropertyDelegate(Of T)(ByVal control As Control, ByVal [property] As Expression(Of Func(Of T)), ByVal value As T)
    Private Delegate Function GetThreadSaferopertyDelegate(Of T)(ByVal control As Control, ByVal [property] As Expression(Of Func(Of T))) As T
    Private Delegate Sub InvokeThreadSafeMethodDelegate(ByVal control As Control, ByVal method As Expression(Of Action))
    Private Delegate Function InvokeThreadSafeFunctionDelegate(Of T)(ByVal control As Control, ByVal [function] As Expression(Of Func(Of T))) As T
 
    ''' <summary>
    ''' Sets the specified property of this control to the specified value safely across threads by invoking a delegate if necessary.
    ''' </summary>
    ''' <typeparam name="T">The type of the property. Can usually be inferred from usage.</typeparam>
    ''' <param name="control">The control to set the property on.</param>
    ''' <param name="property">The property to set as a lambda expression.</param>
    ''' <param name="value">The new value of the property.</param>
    <Extension()> _
    Public Sub SetThreadSafeProperty(Of T)(ByVal control As Control, ByVal [property] As Expression(Of Func(Of T)), ByVal value As T)
        If (control.InvokeRequired) Then
            Dim del = New SetThreadSafePropertyDelegate(Of T)(AddressOf SetThreadSafeProperty)
            control.Invoke(del, control, [property], value)
        Else
            Dim propertyInfo = GetPropertyInfo([property])
            If (propertyInfo IsNot Nothing) Then
                propertyInfo.SetValue(control, value, Nothing)
            End If
        End If
    End Sub
 
    ''' <summary>
    ''' Gets the value of the specified property of this control safely across threads by invoking a delegate if necessary.
    ''' </summary>
    ''' <typeparam name="T">The type of the property. Can usually be inferred from usage.</typeparam>
    ''' <param name="control">The control to get the property from.</param>
    ''' <param name="property">The property to get the value from as a lambda expression.</param>
    ''' <returns>The value of the specified property.</returns>
    <Extension()> _
    Public Function GetThreadSafeProperty(Of T)(ByVal control As Control, ByVal [property] As Expression(Of Func(Of T))) As T
        If (control.InvokeRequired) Then
            Dim del = New GetThreadSaferopertyDelegate(Of T)(AddressOf GetThreadSafeProperty)
            Return DirectCast(control.Invoke(del, control, [property]), T)
        Else
            Dim propertyInfo = GetPropertyInfo([property])
            If (propertyInfo IsNot Nothing) Then
                Return DirectCast(propertyInfo.GetValue(control, Nothing), T)
            End If
        End If
        Return Nothing
    End Function
 
    ''' <summary>
    ''' Invokes a method of this control safely across threads by invoking a delegate if necessary.
    ''' </summary>
    ''' <param name="control">The control to invoke the method on.</param>
    ''' <param name="method">The method to invoke as an expression.</param>
    <Extension()> _
    Public Sub InvokeThreadSafeMethod(ByVal control As Control, ByVal method As Expression(Of Action))
        If (control.InvokeRequired) Then
            Dim del = New InvokeThreadSafeMethodDelegate(AddressOf InvokeThreadSafeMethod)
            control.Invoke(del, control, method)
        Else
            method.Compile().DynamicInvoke()
        End If
    End Sub
 
    ''' <summary>
    ''' Invokes a function of this control safely across threads by invoking a delegate if necessary.
    ''' </summary>
    ''' <typeparam name="T">The return type of the function to invoke. Can usually be inferred from usage.</typeparam>
    ''' <param name="control">The control to invoke the function on.</param>
    ''' <param name="function">The function to invoke as an expression.</param>
    ''' <returns>The result of the function to invoke.</returns>
    <Extension()> _
    Public Function InvokeThreadSafeFunction(Of T)(ByVal control As Control, ByVal [function] As Expression(Of Func(Of T))) As T
        If (control.InvokeRequired) Then
            Dim del = New InvokeThreadSafeFunctionDelegate(Of T)(AddressOf InvokeThreadSafeFunction)
            Return DirectCast(control.Invoke(del, control, [function]), T)
        Else
            Return DirectCast([function].Compile().DynamicInvoke(), T)
        End If
    End Function
 
    Private Function GetMemberInfo(ByVal expression As Expression) As MemberInfo
        Dim memberExpression As MemberExpression
        Dim lambda = DirectCast(expression, LambdaExpression)
        If (TypeOf lambda.Body Is UnaryExpression) Then
            memberExpression = DirectCast(DirectCast(lambda.Body, UnaryExpression).Operand, MemberExpression)
        Else
            memberExpression = DirectCast(lambda.Body, MemberExpression)
        End If
        Return memberExpression.Member
    End Function
 
    Private Function GetPropertyInfo(ByVal expression As Expression) As PropertyInfo
        Dim memberInfo = GetMemberInfo(expression)
        If (memberInfo.MemberType = Reflection.MemberTypes.Property) Then
            Return DirectCast(memberInfo, PropertyInfo)
        End If
        Return Nothing
    End Function
 
End Module

It looks complicated but usage is pretty easy. You'll need to pass the property as a lambda expression (which turns out something like "Function() <property here>"), as well as the value you want to set it to. Even though the extension method takes a type parameter, it can usually be inferred from the objects you pass (the property lambda and the value) so you won't need to supply it.

Usage examples:

' Set label text
Label1.SetThreadSafeProperty(Function() Label1.Text, "test text")
 
' Disable button
Button1.SetThreadSafeProperty(Function() Button1.Enabled, false)
 
' Get textbox text
Dim text As String = TextBox1.GetThreadSafeProperty(Function() TextBox1.Text)
 
' Invoke some method (note: Sub() instead of Function() !)
CustomControl1.InvokeThreadSafeMethod(Sub() CustomControl1.SomeMethod("a", 3))
 
' Invoke some function
Dim x = CustomControl2.InvokeThreadSafeFunction(Function() CustomControl2.SomeFunction(y))

I'm not that much into threading yet, but it seems to work fine for a few little tests I've done.

The only drawback is that it uses Reflection which can be a little slow, but it's only one call and I think it should be fine.

I'm open to suggestions! One thing I don't much like is that it seems a little redundant to use the control name twice (first to call the extension method on, second to pass the property you want to set), but the only way I can think of to get around that is to pass the property name as a string, and I don't like that approach at all as it's error prone (no compile errors if you miss-spell it)...


Enjoy.