I Code, Therefore I Am

Extension Methods can come in very handy, because in a lot of cases whatever you’re working with doesn’t have the exact functionality you’re looking for, and an Extension Method allows you to add this functionality (or extend it) without having to create a new class inheriting from said object.

One extension method I wrote some time ago happens to be one that I use the most. It’s an extensions method that takes care of controls InvokeRequired property, which helps prevent a cross-thread exception when using multiple threads in an application, God knows I’ve enjoyed enough of those in my programming career.

I will show how this extension method looks in both C# and VB.NET, and how you would use it in both languages. This extension method is generic, meaning it can be used for any control that you can think of, and it utilizes ISynchronizeInvoke, which gives us a synchronously or asynchronously execute a delegate. You provide it with a control and an Action Delegate for it to execute.

NOTE: In VB.NET an Extension method can only be created in a Module and must be marked with the ExtensionAttribute class. Here’s how our Extension method looks in VB.NET

Imports System.ComponentModel

Module InvokeRequiredHandler
    <System.Runtime.CompilerServices.Extension()> _
    Public Sub HandleInvokeRequired(Of T As ISynchronizeInvoke)(ByVal controlToInvoke As T, ByVal actionToPerform As Action(Of T))
        'Check to see if the control's InvokeRequired property is true
        If controlToInvoke.InvokeRequired Then
            'Use Invoke() to invoke your action
            controlToInvoke.Invoke(actionToPerform, New Object() {controlToInvoke})
        Else
            'Perform the action
            actionToPerform(controlToInvoke)
        End If
    End Sub
End Module

And this is how it looks in C#

using System.ComponentModel;

namespace ExtensionMethods.Example.Core
{
    public static class SynchronizeInvoke
    {
        public static void CustomInvoke<T>(this T @controlToInvoke, Action<T> actionToPerform) where T : ISynchronizeInvoke
        {
            if (@controlToInvoke.InvokeRequired)
                @controlToInvoke.Invoke(actionToPerform, new object[] { @controlToInvoke });
            else
                actionToPerform(@controlToInvoke);
        }
    }
}

Now that it’s an Extension method it will show up in Intellisense in Visual Studio for our controls. When using it in VB.NET we would use it like so (In this example I’m using a ListView class to add items to it from within a BackgroundWorker, remember this is just an example and it will work for all the controls):

ListViewControl.HandleInvokeRequired(Function(l As ListView) l.Items.Add(lv))

When in C# we can use a Lambda operator and the call looks like this:

ListViewControl.HandleInvokeRequired(lv => lv.Items.Add(lv))

Both languages use a Lambda Expression, but VB.NET uses the format Function(parameter) while C# allows for the use of the lambda operator. I think the C# method is easier to read and more intuitive but that’s just me. Some say the lambda operator is too cryptic but that’s a discussion for another time. So that’s our InvokeRequired extension method, hope you found this useful and thanks for reading

Happy Programming!

Tags: C#, extension methods, ISynchronizeInvoke, System.Action Delegate, VB.NET

This entry was posted by Richard McCutchen on Saturday, July 3rd, 2010 at 08:59 and is filed under C#, Extension Methods, General .Net, VB.NET. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.