Search results for 'app:weblogs' matching tag 'WinForms'

Extension Methods And Type Inference In Action

paulo — Mon, 18 Apr 2011 05:00:00 GMT

I make extensive use of extension methods, either to make classes small and focused or to improve readability.

While porting a .NET 1.1 WinForms application to C# 3.0, I found lots of code like this:

delegate int Int32DelegateStringBoolean(string text, bool flag);

void DoStuff()
{
    // ...

    var x = (int)this.Invoke(new Int32DelegateStringBoolean(GetStuff), new object[] { "some text", true });

    // ...
}

int GetStuff(string text, bool flag)
{
    // ...
}

.NET 2.0 introduced a nicer API and it became possible to write the code calling Invoke like this:

var x = (int)this.Invoke(new Int32DelegateStringBoolean(GetStuff), "some text", true);

But it’s still not strongly typed enough to my taste and the compiler can’t verify if any mistake was made. This will still be valid code at compile time that will break at run time:

var x = (long)this.Invoke(new Int32DelegateStringBoolean(GetStuff), "some text", 10M, 5);

To make the code safer and more readable, I decided to create extension methods to extend the Control class and provide strongly type Invoke methods.

Instead of defining custom delegates for each need, I used the Action and Func delegates exiting in the framework and wrote extension methods like this:

public static TResult InvokeFunc<T1, T2, TResult>(this Control control, Func<T1, T2, TResult> func, T1 param1, T2 param2)
{
    return (TResult)(control.Invoke(func, param1, param2));
}

Now I can replace the call to Invoke with this call:

var x = this.InvokeFunc<string, bool, int>(new Func<string, bool, int>(GetStuff), "some text", true);

And the compiler is now able to match the type of the delegate, the parameters and the return value.

Starting with the C# 2.0 compiler, there is no need to write the delegate instantiation if the compiler can infer the type of the delegate, which makes the code even simpler:

var x = this.InvokeFunc<string, bool, int>(GetStuff, "some text", true);

The C# compiler is even capable of inferring the type parameters of the InvokeFunc method making the code even smaller and more readable:

var x = this.InvokeFunc(GetStuff, "some text", true);

A lot better than what we started with, isn’t it?

So far, I’ve implemented these:

/// <summary>
/// Provides extended functionality to <see cref="System.Windows.Forms.Control"/>.
/// </summary>
public static class ControlExtensions
{
    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to invoke the function on.</param>
    /// <param name="func">The function to invoke.</param>
    /// <returns>A <typeparamref name="TResult"/> that contains the return value from the function (<paramref name="func"/>) being invoked.</returns>
    public static TResult InvokeFunc<TResult>(this Control control, Func<TResult> func)
    {
        return (TResult)(control.Invoke(func));
    }

    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the parameter of the function.</typeparam>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to invoke the function on.</param>
    /// <param name="func">The function to invoke.</param>
    /// <param name="param1">The parameter of the action.</param>
    /// <returns>A <typeparamref name="TResult"/> that contains the return value from the function (<paramref name="func"/>) being invoked.</returns>
    public static TResult InvokeFunc<T1, TResult>(this Control control, Func<T1, TResult> func, T1 param1)
    {
        return (TResult)(control.Invoke(func, param1));
    }

    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the function.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the function.</typeparam>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to invoke the function on.</param>
    /// <param name="func">The function to invoke.</param>
    /// <param name="param1">The first parameter of the function.</param>
    /// <param name="param2">The second parameter of the function.</param>
    /// <returns>A <typeparamref name="TResult"/> that contains the return value from the function (<paramref name="func"/>) being invoked.</returns>
    public static TResult InvokeFunc<T1, T2, TResult>(this Control control, Func<T1, T2, TResult> func, T1 param1, T2 param2)
    {
        return (TResult)(control.Invoke(func, param1, param2));
    }

    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the function.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the function.</typeparam>
    /// <typeparam name="T3">The type of the third parameter of the function.</typeparam>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to invoke the function on.</param>
    /// <param name="func">The function to invoke.</param>
    /// <param name="param1">The first parameter of the function.</param>
    /// <param name="param2">The second parameter of the function.</param>
    /// <param name="param3">The third parameter of the function.</param>
    /// <returns>A <typeparamref name="TResult"/> that contains the return value from the function (<paramref name="func"/>) being invoked.</returns>
    public static TResult InvokeFunc<T1, T2, T3, TResult>(this Control control, Func<T1, T2, T3, TResult> func, T1 param1, T2 param2, T3 param3)
    {
        return (TResult)(control.Invoke(func, param1, param2, param3));
    }

    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the function.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the function.</typeparam>
    /// <typeparam name="T3">The type of the third parameter of the function.</typeparam>
    /// <typeparam name="T4">The type of the forth parameter of the function.</typeparam>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to invoke the function on.</param>
    /// <param name="func">The function to invoke.</param>
    /// <param name="param1">The first parameter of the function.</param>
    /// <param name="param2">The second parameter of the function.</param>
    /// <param name="param3">The third parameter of the function.</param>
    /// <param name="param4">The forth parameter of the function.</param>
    /// <returns>A <typeparamref name="TResult"/> that contains the return value from the function (<paramref name="func"/>) being invoked.</returns>
    public static TResult InvokeFunc<T1, T2, T3, T4, TResult>(this Control control, Func<T1, T2, T3, T4, TResult> func, T1 param1, T2 param2, T3 param3, T4 param4)
    {
        return (TResult)(control.Invoke(func, param1, param2, param3, param4));
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <param name="control">The control to invoke the action on.</param>
    /// <param name="action">The action to invoke.</param>
    public static void InvokeAction(this Control control, Action action)
    {
        control.Invoke(action);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T">The type of the parameter.</typeparam>
    /// <param name="control">The control to invoke the action on.</param>
    /// <param name="action">The action to invoke.</param>
    /// <param name="param">The parameter of the action.</param>
    public static void InvokeAction<T>(this Control control, Action<T> action, T param)
    {
        control.Invoke(action, param);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the action.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the action.</typeparam>
    /// <param name="control">The control to invoke the action on.</param>
    /// <param name="action">The action to invoke.</param>
    /// <param name="param1">The first parameter of the action.</param>
    /// <param name="param2">The second parameter of the action.</param>
    public static void InvokeAction<T1, T2>(this Control control, Action<T1, T2> action, T1 param1, T2 param2)
    {
        control.Invoke(action, param1, param2);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the action.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the action.</typeparam>
    /// <typeparam name="T3">The type of the third parameter of the action.</typeparam>
    /// <param name="control">The control to invoke the action on.</param>
    /// <param name="action">The action to invoke.</param>
    /// <param name="param1">The first parameter of the action.</param>
    /// <param name="param2">The second parameter of the action.</param>
    /// <param name="param3">The third parameter of the action.</param>
    public static void InvokeAction<T1, T2, T3>(this Control control, Action<T1, T2, T3> action, T1 param1, T2 param2, T3 param3)
    {
        control.Invoke(action, param1, param2, param3);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the action.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the action.</typeparam>
    /// <typeparam name="T3">The type of the third parameter of the action.</typeparam>
    /// <typeparam name="T4">The type of the forth parameter of the action.</typeparam>
    /// <param name="control">The control to invoke the action on.</param>
    /// <param name="action">The action to invoke.</param>
    /// <param name="param1">The first parameter of the action.</param>
    /// <param name="param2">The second parameter of the action.</param>
    /// <param name="param3">The third parameter of the action.</param>
    /// <param name="param4">The forth parameter of the action.</param>
    public static void InvokeAction<T1, T2, T3, T4>(this Control control, Action<T1, T2, T3, T4> action, T1 param1, T2 param2, T3 param3, T4 param4)
    {
        control.Invoke(action, param1, param2, param3, param4);
    }
    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to BeginInvoke the function on.</param>
    /// <param name="func">The function to BeginInvoke.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeFunc<TResult>(this Control control, Func<TResult> func)
    {
        return control.BeginInvoke(func);
    }

    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the parameter of the function.</typeparam>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to BeginInvoke the function on.</param>
    /// <param name="func">The function to BeginInvoke.</param>
    /// <param name="param1">The parameter of the action.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeFunc<T1, TResult>(this Control control, Func<T1, TResult> func, T1 param1)
    {
        return control.BeginInvoke(func, param1);
    }

    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the function.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the function.</typeparam>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to BeginInvoke the function on.</param>
    /// <param name="func">The function to BeginInvoke.</param>
    /// <param name="param1">The first parameter of the function.</param>
    /// <param name="param2">The second parameter of the function.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeFunc<T1, T2, TResult>(this Control control, Func<T1, T2, TResult> func, T1 param1, T2 param2)
    {
        return control.BeginInvoke(func, param1, param2);
    }

    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the function.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the function.</typeparam>
    /// <typeparam name="T3">The type of the third parameter of the function.</typeparam>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to BeginInvoke the function on.</param>
    /// <param name="func">The function to BeginInvoke.</param>
    /// <param name="param1">The first parameter of the function.</param>
    /// <param name="param2">The second parameter of the function.</param>
    /// <param name="param3">The third parameter of the function.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeFunc<T1, T2, T3, TResult>(this Control control, Func<T1, T2, T3, TResult> func, T1 param1, T2 param2, T3 param3)
    {
        return control.BeginInvoke(func, param1, param2, param3);
    }

    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the function.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the function.</typeparam>
    /// <typeparam name="T3">The type of the third parameter of the function.</typeparam>
    /// <typeparam name="T4">The type of the forth parameter of the function.</typeparam>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to BeginInvoke the function on.</param>
    /// <param name="func">The function to BeginInvoke.</param>
    /// <param name="param1">The first parameter of the function.</param>
    /// <param name="param2">The second parameter of the function.</param>
    /// <param name="param3">The third parameter of the function.</param>
    /// <param name="param4">The forth parameter of the function.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeFunc<T1, T2, T3, T4, TResult>(this Control control, Func<T1, T2, T3, T4, TResult> func, T1 param1, T2 param2, T3 param3, T4 param4)
    {
        return control.BeginInvoke(func, param1, param2, param3, param4);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <param name="control">The control to BeginInvoke the action on.</param>
    /// <param name="action">The action to BeginInvoke.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeAction(this Control control, Action action)
    {
        return control.BeginInvoke(action);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T">The type of the parameter.</typeparam>
    /// <param name="control">The control to BeginInvoke the action on.</param>
    /// <param name="action">The action to BeginInvoke.</param>
    /// <param name="param">The parameter of the action.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeAction<T>(this Control control, Action<T> action, T param)
    {
        return control.BeginInvoke(action, param);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the action.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the action.</typeparam>
    /// <param name="control">The control to BeginInvoke the action on.</param>
    /// <param name="action">The action to BeginInvoke.</param>
    /// <param name="param1">The first parameter of the action.</param>
    /// <param name="param2">The second parameter of the action.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeAction<T1, T2>(this Control control, Action<T1, T2> action, T1 param1, T2 param2)
    {
        return control.BeginInvoke(action, param1, param2);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the action.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the action.</typeparam>
    /// <typeparam name="T3">The type of the third parameter of the action.</typeparam>
    /// <param name="control">The control to BeginInvoke the action on.</param>
    /// <param name="action">The action to BeginInvoke.</param>
    /// <param name="param1">The first parameter of the action.</param>
    /// <param name="param2">The second parameter of the action.</param>
    /// <param name="param3">The third parameter of the action.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeAction<T1, T2, T3>(this Control control, Action<T1, T2, T3> action, T1 param1, T2 param2, T3 param3)
    {
        return control.BeginInvoke(action, param1, param2, param3);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the action.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the action.</typeparam>
    /// <typeparam name="T3">The type of the third parameter of the action.</typeparam>
    /// <typeparam name="T4">The type of the forth parameter of the action.</typeparam>
    /// <param name="control">The control to BeginInvoke the action on.</param>
    /// <param name="action">The action to BeginInvoke.</param>
    /// <param name="param1">The first parameter of the action.</param>
    /// <param name="param2">The second parameter of the action.</param>
    /// <param name="param3">The third parameter of the action.</param>
    /// <param name="param4">The forth parameter of the action.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeAction<T1, T2, T3, T4>(this Control control, Action<T1, T2, T3, T4> action, T1 param1, T2 param2, T3 param3, T4 param4)
    {
        return control.BeginInvoke(action, param1, param2, param3, param4);
    }
}

Use them if you need to.

Setting a Form as a Startup Form with Visual Studio

DeborahK — Wed, 15 Dec 2010 06:00:00 GMT

The startup form is the first form that is launched when your application is executed. By default, a Windows Forms project creates a default form when the project is created. This form is set as the startup form.

You can change the startup form to any form within your application following the steps below. In this example, the report form is set as the startup form for testing purposes.

To Set a Form as a Startup Form:

In C#:

Modify the Program.cs file as follows:

static void Main()
{
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);
    Application.Run(new ReportWin());
}

In VB:

1) Double-click on My Project under the project in Solution Explorer.

2) Click the Application tab.

3) Set the Startup form.

Use this technique any time you want to change the start up form for the application.

Enjoy!

HowTo: Crear una pantalla de inicio (splash screen)

lfranco — Fri, 26 Nov 2010 06:00:00 GMT

Nota: Otro post en respuesta a una pregunta bastante habitual en los foros MSDN: ¿Cómo crear una pantalla de inicio para mi aplicación?

He creado un pequeño proyecto de ejemplo, que pueda servir como plantilla base para que cada uno se lo personalice para su aplicación. Este proyecto tiene lo básico: Un formulario sin bordes con una imagen, una barra de progreso, una etiqueta para el título, otra para ir mostrando mensajes, y un botón por si se desea cancelar la carga del programa (al estilo Office 2010).

Él proyecto es muy sencillo y lo podéis descargar desde aquí:

La pantalla de inicio utiliza un thread para mostrar los diferentes mensajes al cargar, ya que así no se bloquea la aplicación (y la barra de progreso). Esto es así porque en el proyecto de ejemplo, al cargar la pantalla de inicio se lanza un segundo hilo que llama a un método ‘initApplication’, y desde éste método simulamos varios procesos largos (en realidad de un segundo cada uno), y cada vez que se inicia uno de ellos hay que cambiar el mensaje:

public void initApplication()

    Thread.Sleep(DEFAULT_TIME);

    this.Invoke((MethodInvoker)(() => setMessage("Searching for updates...")));

    Thread.Sleep(DEFAULT_TIME);

    this.Invoke((MethodInvoker)(() => setMessage("Connectiong to database...")));

    Thread.Sleep(DEFAULT_TIME);

    this.Invoke((MethodInvoker)(() => setMessage("Connectiong to webservices...")));

    Thread.Sleep(DEFAULT_TIME);

    this.Invoke((MethodInvoker)(() => setMessage("Loading settings...")));

    Thread.Sleep(DEFAULT_TIME);

    this.Invoke((MethodInvoker)(() => setMessage("Loading user preferences...")));

    Thread.Sleep(DEFAULT_TIME);

    this.Invoke((MethodInvoker)(() => setMessage("Starting application...")));

    Thread.Sleep(DEFAULT_TIME);

    if (this.InvokeRequired) this.Invoke(new Action(finishProcess));

Recordar que desde un hilo que no sea el hilo principal, en .NET no se puede actualizar la interfaz de usuario directamente. En su lugar debemos usar el método Invoke. En el ejemplo anterior llamamos a un método ‘setMessage’ que se encarga de mostrar el texto en la etiqueta correspondiente. Para poder llamar a este método mediante Invoke tenemos dos opciones: Podemos usar un MethodInvoker o un Action, en nuestro caso usaremos el primero, ya que un Action se usa cuando no hay paso de parámetros, y este método precisa de un parámetro con el mensaje a mostrar:

public void setMessage(string msg)

    messageLabel.Text = msg;

Una vez finalizado el proceso de carga, se cierra el formulario y se devuelve un DialogResult = Ok. Por otro lado si en cualquier momento de la carga el usuario ha pulsado el botón ‘close’, se hace lo mismo pero devolviendo un DialogResult = Cancel:

private void finishProcess()

    this.DialogResult = System.Windows.Forms.DialogResult.OK;

    this.Close();

void closeButton_Click(object sender, EventArgs e)

    this.DialogResult = System.Windows.Forms.DialogResult.Cancel;

    this.Close();

Como veis el proyecto es muy sencillo, sólo debéis recordar un detalle importante: En una aplicación WinForms el punto de entrada a la misma se define en el método estático Main del Program.cs, y aquí hay una línea que inicializa el formulario inicial de nuestra aplicación:

Application.Run(new fMain());

Lo primero que solemos pensar es que aquí deberíamos lanzar el formulario fSplashScreen, y al cerrarlo mostrar el formulario principal, verdad? Pues no, no podemos hacer eso. El motivo no es otro que este formulario inicial va a definir el ciclo de vida de nuestra aplicación, y si lo cerramos, cerramos la aplicación. Ya se que en VB puede cambiarse este comportamiento, pero entre nosotros... hacerlo siempre me ha parecido una chapuza :-)

Así pues, aquí lanzaremos el formulario principal, y éste, al cargarse (mientras todavía no es visible) lanzará la pantalla de inicio de forma modal y esperará el valor de retorno. Si al cerrarse la pantalla de bienvenida el valor de retorno es Ok, continúa la carga y muestra el formulario principal, en caso contrario cierra el formulario principal y con por ende la aplicación:

void fMain_Load(object sender, EventArgs e)

    showSplashScreen();

private void showSplashScreen()

    using (fSplashScreen fsplash = new fSplashScreen())

        if (fsplash.ShowDialog() == System.Windows.Forms.DialogResult.Cancel) this.Close();

Espero que sirva como ejemplo a todos aquellos que desean tener una pantalla de inicio para sus aplicaciones. Un saludo!

Andorra, Noviembre 2010

Associating Code with a Tag using Delegates II

DeborahK — Fri, 19 Nov 2010 06:00:00 GMT

This prior post demonstrated how to use delegates to associated code with a Tag in a WinForms control. This post shows how to accomplish the same thing using Lambda expressions to define the delegate.

To try out this example, create a WinForms application and add a TreeView control to the form. Then add the code below.

In C#:

public delegate void DisplayMessage(string value);

private void Form1_Load(object sender, EventArgs e)
{
var rootTreeNode = treeView1.Nodes.Add("Phones");

    var appleTreeNode = rootTreeNode.Nodes.Add("IPhone is the best");
    appleTreeNode.Tag = new DisplayMessage(
                          x => MessageBox.Show("Apple: " + x));

    var microsoftTreeNode = rootTreeNode.Nodes.Add("Win 7 Phone is the best");
    microsoftTreeNode.Tag = new DisplayMessage(
                          x => MessageBox.Show("Microsoft: " + x));

treeView1.ExpandAll();
}

private void treeView1_DoubleClick(object sender, EventArgs e)
{
var messageDelegate = (DisplayMessage)treeView1.SelectedNode.Tag;
messageDelegate.Invoke(treeView1.SelectedNode.Text);
}

In VB:

Public Delegate Sub DisplayMessage(ByVal value As String)

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
Dim rootTreeNode = TreeView1.Nodes.Add("Phones")

    Dim appleTreeNode = rootTreeNode.Nodes.Add("IPhone is the best")
    appleTreeNode.Tag = New DisplayMessage(
                         Sub(x) MessageBox.Show("Apple: " & x))

    Dim microsoftTreeNode = rootTreeNode.Nodes.Add("Win 7 Phone is the best")
    microsoftTreeNode.Tag = New DisplayMessage(
                        Sub(x) MessageBox.Show("Microsoft: " & x))

TreeView1.ExpandAll()
End Sub

Private Sub TreeView1_DoubleClick(ByVal sender As Object,
                ByVal e As EventArgs) Handles TreeView1.DoubleClick
    Dim messageDelegate = TryCast(TreeView1.SelectedNode.Tag,
                                                DisplayMessage)
    If messageDelegate IsNot Nothing Then
        messageDelegate.Invoke(TreeView1.SelectedNode.Text)
    End If
End Sub

The first line of code declares a delegate. If you have not worked with delegates before, see this prior blog post for more information.

The Load event populates the Treeview with two child nodes. A new instance of the delegate is stored in the Tag property of each node.

The delegate instance constructor defines the code to call when the user double-clicks on the node. This code is defined using a Lambda expression. If you have not worked with a Lambda expression before, see this prior blog post for more information.

The DoubleClick event then pulls the delegate from the Tag property and calls it using the Invoke method, passing the appropriate parameters.

Use this technique any time you want to define code to execute in the Tag property of a control.

Enjoy!

Associating Code with a Tag using Delegates

DeborahK — Fri, 19 Nov 2010 06:00:00 GMT

Many of the Windows Forms controls have a Tag property that you can use to store data associated with the control. For example, TextBoxes have a Tag property so you could store additional information about each TextBox in the Tag. For TreeView controls, each node has its own Tag property, so you can associate data with each node. But what if you wanted to associated code with each Tag?

This post details how to use delegates to associated code with a Tag. It uses a TreeView as an example, but any control with a Tag property could use this technique.

If you want to use a Lambda expression instead of a method to define the delegate, see this later post.

To try out this example, create a WinForms application and add a TreeView control to the form. Then add the code below.

In C#:

public delegate void DisplayMessage(string value);

private void Form1_Load(object sender, EventArgs e)
{
var rootTreeNode = treeView1.Nodes.Add("Phones");

var appleTreeNode = rootTreeNode.Nodes.Add("IPhone is the best");
appleTreeNode.Tag = new DisplayMessage(AppleMessage);

var microsoftTreeNode = rootTreeNode.Nodes.Add("Win 7 Phone is the best");
microsoftTreeNode.Tag = new DisplayMessage(MicrosoftMessage);

treeView1.ExpandAll();
}

public void AppleMessage(string value)
{
MessageBox.Show("Apple: " + value);
}
public void MicrosoftMessage(string value)
{
MessageBox.Show("Microsoft: " + value);
}

private void treeView1_DoubleClick(object sender, EventArgs e)
{
var messageDelegate = (DisplayMessage)treeView1.SelectedNode.Tag;
messageDelegate.Invoke(treeView1.SelectedNode.Text);
}

In VB:

Public Delegate Sub DisplayMessage(ByVal value As String)

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
Dim rootTreeNode = TreeView1.Nodes.Add("Phones")

Dim appleTreeNode = rootTreeNode.Nodes.Add("IPhone is the best")
appleTreeNode.Tag = New DisplayMessage(AddressOf AppleMessage)

    Dim microsoftTreeNode = rootTreeNode.Nodes.Add("Win 7 Phone is the best")
    microsoftTreeNode.Tag =
                     New DisplayMessage(AddressOf MicrosoftMessage)

TreeView1.ExpandAll()
End Sub

Public Sub AppleMessage(ByVal value As String)
MessageBox.Show("Apple: " & value)
End Sub

Public Sub MicrosoftMessage(ByVal value As String)
MessageBox.Show("Microsoft: " & value)
End Sub

Private Sub TreeView1_DoubleClick(ByVal sender As Object,
                ByVal e As EventArgs) Handles TreeView1.DoubleClick
    Dim messageDelegate = TryCast(TreeView1.SelectedNode.Tag,
                                               DisplayMessage)
    If messageDelegate IsNot Nothing Then
        messageDelegate.Invoke(TreeView1.SelectedNode.Text)
    End If
End Sub

The first line of code declares a delegate. If you have not worked with delegates before, see this blog post for more information.

The Load event populates the Treeview with two child nodes. A new instance of the delegate is stored in the Tag property of each node. The delegate instance defines the method to call when the user double-clicks on the node.

The AppleMessage method and the MicrosoftMessage method define the two methods to execute. These methods must have a signature that matches the signature of the delegate. In this case, it is a routine that takes one string parameter and does not return a value. But the delegate could define any signature and the methods must then match the delegate's signature.

In this example, the methods displayed a messageBox, but the method could do anything. It could perform any type of calculation or perform any processing.

The DoubleClick event then pulls the delegate from the Tag property and calls it using the Invoke method, passing the appropriate parameters.

Use this technique any time you want to define code to execute in the Tag property of a control.

Enjoy!

Sorting Lists with Null Values

DeborahK — Sat, 30 Oct 2010 05:00:00 GMT

When working with data, you often have values that are null. For example, you may allow entry of a user's birthday, but not require entry. So some of your rows may contain a null date. Or your application may track a customer's last order date, which will be null if you track potential customers that have not yet made a purchase.

When you sort a list that contains null values, the null values will be first in the list as shown below:

But what if you want the null values at the end and not at the beginning?

This post demonstrates one technique for sorting your null values to the bottom of the list.

First, some prerequisite code to build the list of business objects that are bound to the grid.

In C#:

Here is the Customer class:

public class Customer
{
    public int CustomerId { get; set; }
    public string LastName { get; set; }
    public string FirstName { get; set; }
    public string EmailAddress { get; set; }
    public DateTime? LastOrderDate { get; set; }
}

And here is the one line of code to build the list of customers:

    List<Customer> custList = new List<Customer>
                {new Customer()
                      { CustomerId = 1,
                        FirstName="Bilbo",
                        LastName = "Baggins",
                        EmailAddress = "bb@hob.me",
                        LastOrderDate = new DateTime(2010,9,1)},
                new Customer()
                      { CustomerId = 2,
                        FirstName="Frodo",
                        LastName = "Baggins",
                        EmailAddress = "fb@hob.me",
                        LastOrderDate = null},
                new Customer()
                      { CustomerId = 3,
                        FirstName = "Samwise",
                        LastName = "Gamgee",
                        EmailAddress = "sg@hob.me",
                        LastOrderDate = new DateTime(2010, 6, 15),
                      },
                new Customer()
                      { CustomerId = 4,
                        FirstName = "Rosie",
                        LastName = "Cotton",
                        EmailAddress = "rc@hob.me",
                        LastOrderDate = new DateTime(2010, 6, 15),
                      }
                };

The code to bind this list to the grid is:

var sortedList = custList.OrderBy(c => c.LastOrderDate);
dataGridView1.DataSource = sortedList.ToList();

In VB:

Here is the Customer class:

Public Class Customer
    Public Property CustomerId As Integer
    Public Property LastName As String
    Public Property FirstName As String
    Public Property EmailAddress As String
    Public Property LastOrderDate As DateTime?
End Class

And here is the one line of code to build the list of customers:

Dim custList As New List(Of Customer) From
                 {New Customer() With
                       {.CustomerId = 1,
                         .FirstName = "Bilbo",
                         .LastName = "Baggins",
                         .EmailAddress = "bb@hob.me",
                         .LastOrderDate = New DateTime(2010, 9, 1)},
                 New Customer() With
                       {.CustomerId = 2,
                         .FirstName = "Frodo",
                         .LastName = "Baggins",
                         .EmailAddress = "fb@hob.me",
                         .LastOrderDate = Nothing},
                 New Customer() With
                       {.CustomerId = 3,
                           .FirstName = "Samwise",
                           .LastName = "Gamgee",
                           .EmailAddress = "sg@hob.me",
                           .LastOrderDate = New DateTime(2010, 6, 15)},
                 New Customer() With
                       {.CustomerId = 4,
                           .FirstName = "Rosie",
                           .LastName = "Cotton",
                           .EmailAddress = "rc@hob.me",
                           .LastOrderDate = New DateTime(2010, 6, 15)}
                 }

The code to bind this list to the grid is:

Dim sortedList = custList.OrderBy(Function(c) c.LastOrderDate)
DataGridView1.DataSource = sortedList.ToList()

The first set of code defines the customer business object. Note how the LastOrderDate property is defined as a Nullable structure. This allows the date to hold a null value. Both the C# and VB examples use auto-implemented properties, which provide a shortened property syntax.

See this link for more information about auto-implemented properties.

The second (very long) line of code builds the list of customers. Both the C# and VB code build the list using collection initializer syntax.

The last two lines of code first sort the list using a Lambda expression and then bind that sorted list to a DataGridView.

If you are not familiar with Lambda expressions, see an overview here.

But this example sorts in the default order, with null values first. One way to sort null values to the end is to perform a descending sort. But then all of the rows are sorted in the opposite direction.

If you want an ascending sort for all of the data, but nulls at the end, you can use multiple sorts as shown below.

In C#:

var sortedList = custList
.OrderBy(c => !c.LastOrderDate.HasValue)
.ThenBy(c => c.LastOrderDate);
dataGridView1.DataSource = sortedList.ToList();

In VB:

Dim sortedList = custList.
OrderBy(Function(c) Not c.LastOrderDate.HasValue).
ThenBy(Function(c) c.LastOrderDate)
DataGridView1.DataSource = sortedList.ToList()

This code first sorts by the LastOrderDate's HasValue property. The HasValue property of the Nullable structure defines whether or not the property has a value. So if the property has a value, HasValue is true and if the property is null, HasValue is false. This code checks for "not HasValue", so if the property is null, the expression is true.

Since true values are sorted to the end in an ascending sort, the dates with values will be first in the sort order, then the null values.

The secondary sort (ThenBy), then sorts by the LastOrderDate. This provides the list with the rows in ascending date order, but with the null values last in the list.

Use this technique any time you need to sort a list and ensure that all null values are at the end of the resulting sorted list.

Enjoy!

Using Enter Key as a Tab

DeborahK — Thu, 28 Oct 2010 05:00:00 GMT

A common question on the forums is how to use the Enter key instead of the Tab key to move through the controls on a Windows form. One common approach is to use SendKeys to send a Tab. But here is another option.

NOTE: To use this technique, set the KeyPreview property of the form to True.

In C#:

private void Form1_KeyDown(object sender, KeyEventArgs e)
{
    Control nextControl ;
    if (e.KeyCode == Keys.Enter)
    {
        nextControl = GetNextControl(ActiveControl, !e.Shift);
        if (nextControl == null)
            nextControl = GetNextControl(null, true);
        nextControl.Focus();
        e.SuppressKeyPress = true;
    }
}

In VB:

Private Sub Form1_KeyDown(ByVal sender As Object,
         ByVal e As System.Windows.Forms.KeyEventArgs) _
                                     Handles Me.KeyDown
    Dim nextControl As Control
    If e.KeyCode = Keys.Enter Then
        nextControl = GetNextControl(ActiveControl, Not e.Shift)
        If nextControl Is Nothing Then
            nextControl = GetNextControl(Nothing, True)
        End If
        nextControl.Focus()
        e.SuppressKeyPress = True
    End If
End Sub

This code first checks the key that was pressed down and if it was the Enter key, processes it.

It uses the GetNextControl method to find the next control in the tab order. It checks the Shift key and if the Shift key is also pressed, GetNextControl finds the prior key in the tab order.

If GetNextControl does not find another control (because it runs into the end of the tab order), it calls GetNextControl again passing in a null to start back at the other end of the tab order.

For example, if you have four TextBoxes: 1,2,3,4, pressing the Enter key will move you from 1 to 2 to 3 to 4 and then back to 1. Pressing Shift + Enter will move you from 4 to 3 to 2 to 1.

Use this technique any time your users want to use the Enter key instead of the Tab key to move through the controls on a Windows form.

Hope this helps.

WinForms Checklist

DeborahK — Tue, 21 Sep 2010 05:00:00 GMT

There are endless numbers of details you have to contend with when building great software. So it is easy to forget about some of the small ones, especially when it comes to the UI. So I use a checklist like this one to help ensure I covered all of my bases.

Form

Related controls are grouped together
Controls are in a logical sequence
Controls are aligned appropriately
Tab order is set
Standard font family and size are set
Title bar text is descriptive

Modal Dialog

Minimize button disabled
Maximize button disabled

Resizable Dialog

Minimum size defined

Prevents the form from being resized too small to be usable

Controls appropriately anchored/docked to size as the dialog resizes

No resize code should be required in most cases

Controls

All text is spelled correctly
Labels are consistent in tense and terminology
Tooltips defined on all appropriate controls
Disabled controls are grayed out and not accessible
Buttons are all a consistent size and location on the screen

Validation

All required fields are validated

All required fields are distinguished in some manner, such as bolding the label, adding an asterisk, or highlighting the control (pick one technique and use it consistently)

All numeric fields are validated

Use this checklist as you finish each one of your WinForm UI components so you don't have to sweat the details.

Enjoy!

Setting WinForms Colors to a Named, RGB, or Hex Value

DeborahK — Tue, 17 Aug 2010 05:00:00 GMT

Sometimes you want to add a little color to your WinForms controls. WinForms comes with a large set of named colors that you can use.

NOTE: Be sure to import a reference to System.Drawing.

For example

In C#:

textBox1.BackColor = Color.Linen;

In VB:

textBox1.BackColor = Color.Linen

But what if you want to display a color that is not one of the named colors? Then you can use the Color.FromArgb method to define your color by specifying the red, green, and blue values.

In C#:

textBox1.BackColor = Color.FromArgb(250, 245, 235);

In VB:

textBox1.BackColor = Color.FromArgb(250, 245, 235)

Ah, but what if you have the color defined as a hexadecimal value? Well, you could use Bing/Google to find a converter to convert it to RGB. Or you can use the ColorTranslator.FromHtml method.

In C#:

textBox1.BackColor = ColorTranslator.FromHtml("#FAF9F9");

In VB:

textBox3.BackColor = ColorTranslator.FromHtml("#FAF9F9")

Use any of these techniques to add some color to your WinForms applications.

Enjoy!

Updating the UI On an Arbitrary Thread

MichaelTaylor — Sun, 18 Jul 2010 05:00:00 GMT

(Originally published: 5 March 2007)

It is very common to have to perform work on a secondary thread. This allows us to provide a more interactive UI to our users while still allowing us to do lengthy work. Unfortunately this is not as easy as it first appears. We will discuss the problem, the standard v1.x solution and the v2 solution to the problem.

Why Do We Need It

Windows has always had the cardinal rule that a UI element can only be interacted with on the thread that created it. This is because internally Windows still uses a message queue to communicate with UI elements. The message queue is per-thread. It is created on the thread that created the element. This ensures that all messages are serialized to the UI and simplifies our work.

However it is often necessary to do work on secondary threads and still update the UI. In order for this to work we have to actually send the request to the UI's thread and then have it pushed onto the message queue. There are a couple of different ways to do this. We'll look at the most common method in v1.x and v2. .NET v3.x introduces the concept of synchronization contexts which can be used to execute code on specific threads. Synchronization contexts are a lengthy topic that will not be covered in this article.

v1.x Solution - Invoke and InvokeRequired

Every UI element (a control, here on out) has a InvokeRequired property. This property can be called on any thread and indicates whether the calling thread is the thread that created the control. If it is then the property is false otherwise it is true. When working with controls in a multithreaded environment you must check this property. If it is true then you must marshal the request to the UI thread.

You marshal the request to the UI thread using the Invoke or BeginInvoke/EndInvoke methods. These methods can be called on any thread. In each case they accept a delegate, switch to the UI thread and then call the delegate.

...

if (myControl.InvokeRequired)

myControl.Invoke(...);
else
...

To make things easier we generally wrap the above code in a method and then create a delegate with the same signature. This allows us to use one function for two different purposes. The first "version" is called in all cases and determines whether an invoke is required. The second "version" actually does the work on the UI thread. This is a nice way to hide the details from your clients.

public delegate void UpdateProgressDelegate ( int progress );

public void UpdateProgress ( int progress )
{
   //If not on UI thread
   if (myProgress.InvokeRequired)
      myProgress.Invoke(new UpdateProgressDelegate(UpdateProgress), new object[] { progress });
   else
   {
      //Do work here - called on UI thread
      myProgress.Value = progress;
   };
}

As far as your users are concerned this is a clean interface. They simply call UpdateProgress. Internally if an invocation is required to get the call on the UI thread then it does so. However it calls the same method again. The second time it is called it will be done on the UI thread. The biggest downside to this code is that: a) you have to write it, and b) you have to define a delegate. Here is how we might call it.

public void Run ( )
{
   Thread t = new Thread(new ThreadStart(DoWork));
   t.IsBackground = true;
   t.Start();
}

public void UpdateProgress ( int progress )
{ myProgress.Value = progress; }

private void DoWork ( )
{
   for (int nIdx = 1; nIdx <= 100; ++nIdx)
   {
      Thread.Sleep(50);
      UpdateProgress(nIdx);
   };
}

v2 Solution - BackgroundWorker Component

Since this is such a common situation in v2 Microsoft has added the BackgroundWorker component (BWC). This component's sole purpose in life is to do work on a secondary thread and then update the UI. The component requires that you identify the function to run. It will then run the function on a thread pool thread. Once it is complete the component will raise the RunWorkerCompleted event.

public void Run ( )
{
   BackgroundWorker bwc = new BackgroundWorker();
   bwc.DoWork += DoWork;
   bwc.RunWorkerCompleted += OnCompleted;
   bwc.RunWorkerAsync();    //Run it
}

private void OnCompleted ( object sender, RunWorkerCompletedEventArgs e )
{ MessageBox.Show("Done"); }

private void DoWork ( object sender, DoWorkEventArgs e )
{
   for (int nIdx = 1; nIdx <= 100; ++nIdx)
   { Thread.Sleep(50); };
}

Notice a few things about the code. Firstly it is smaller as we don't have to worry about the thread management. Secondly notice we do not have to worry about the UI thread. All events exposed by BWC are raised on the UI thread automatically. Note that you can drop BWC onto your form or control because it shows up in the designer. Personally I prefer to create it on the fly.

There is a problem with the above code. It does not actually update the progress while it is running. In order to raise progress events we need to tell BWC we will be raising progress notifications. We also need to hook up another function to handle the event.

public void Run ( )
{
   BackgroundWorker bwc = new BackgroundWorker();
   bwc.DoWork += DoWork;
   bwc.RunWorkerCompleted += OnCompleted;
   bwc.WorkerReportsProgress = true;
   bwc.ProgressChanged += OnProgressChanged;
   bwc.RunWorkerAsync();    //Run it
}

private void OnProgressChanged ( object sender, ProgressChangedEventArgs e )
{ myProgress.Value = e.ProgressPercentage; }

private void OnCompleted ( object sender, RunWorkerCompletedEventArgs e )
{ MessageBox.Show("Done"); }

private void DoWork ( object sender, DoWorkEventArgs e )
{
   BackgroundWorker bwc = sender as BackgroundWorker;
   for (int nIdx = 1; nIdx <= 100; ++nIdx)
   {
      Thread.Sleep(50);
      bwc.ReportProgress(nIdx);
   };
}

The changes are in bold. Basically the UpdateProgress of earlier changes to OnProgressChanged. Again, it is called on the UI thread. We have to report progress using BWC.ReportProgress.

One final feature of BWC that was not in the original code we wrote is cancellation support. It is often nice to allow users to cancel lengthy tasks. BWC supports this automatically. All you have to do is tell it that you will allow cancellation and then periodically check for a cancellation request. For algorithms that loop you generally check at the beginning of each loop. The more frequently you check the cancellation flag (CancellationPending) the faster your user will see the process be cancelled.

public void Run ( )
{
   BackgroundWorker bwc = new BackgroundWorker();
   bwc.DoWork += DoWork;
   bwc.RunWorkerCompleted += OnCompleted;
   bwc.WorkerReportsProgress = true;
   bwc.ProgressChanged += OnProgressChanged;
   bwc.WorkerSupportsCancellation = true;
   bwc.RunWorkerAsync();    //Run it
}

private void btnCancel_Click ( object sender, EventArgs e )
{ bwc.CancelAsync(); }

private void OnProgressChanged ( object sender, ProgressChangedEventArgs e )
{ myProgress.Value = e.ProgressPercentage; }

private void OnCompleted ( object sender, RunWorkerCompletedEventArgs e )
{
   if (e.Cancelled)
      MessageBox.Show("Cancelled");
   else
      MessageBox.Show("Done");
}

private void DoWork ( object sender, DoWorkEventArgs e )
{
   BackgroundWorker bwc = sender as BackgroundWorker;
   for (int nIdx = 1; nIdx <= 100; ++nIdx)
   {
      if (bwc.CancellationPending)
      {
         e.Cancel = true;
         return
      };

      Thread.Sleep(50);
      bwc.ReportProgress(nIdx);
   };
}

Here we've set the property notifying BWC that we support cancellation and we check for cancellation during each iteration of the loop. We also modified the completion handler to detect whether the operation completed or was cancelled. The only hard part here is actually hooking a control (such as a button) up to cancel the work. If you use the designer to drop the BWC on your form then you can use the field that is created to access the BWC. In the above code it was a local variable so you would have to somehow store the local variable somewhere where the cancel button's click handler could get to it. I leave that for you to figure out.

Why Not Do It Automatically

Some people ask why, if it is so common, Windows does not do this automatically or why the framework developers didn't do it, or why they shouldn't do it themeselves. The answer is performance. As common as it might be most UI interaction still occurs on the appropriate thread. It is not really worth the performance hit to always handle the situation. This is a common theme throughout the framework. Another problem with threading messages is the order. In general if you send two messages (one right after the other) then you expect the first message to be processed first and then the second message. With asynchronous calls this might not be true. Therefore more effort must be put into ensuring that the ordering of messages is not important.

Most classes in the framework are not thread safe. The reasoning is that it adds complexity and degrades performance. A good multithreaded appliation does not allow just any object to be accessed across threads. This would be a bad design. Instead only a select few objects are shared and it is these objects that need to be thread safe, not the entire application.

Until Windows sheds its message queue behavior I'm afraid we are stuck with this limitation. Although I believe WPF has somewhat remedied the situation...