Volevo segnalarvi questo piccolo suggerimento che ho scoperto tempo fa, guardando un webcast di Francesco Balena sulle Best Practice per scrivere codice in .net.
Riguarda la gestione del cursore di attesa nelle winapp, che dovremmo sempre inserire in tutte quelle operazioni che richiedono un po' di tempo. Ovviamente non basta impostare il cursore nello stato wait, ma dobbiamo anche ripristinare lo stato normale una volta che l'operazione è terminata correttamente, oppure nel caso in cui si verifichi un errore.
A tal proposito volevo segnalarvi questa classe che sfrutta l'interfaccia IDisposable per gestire il ripristino del cursore normale:

public class LongOperation : IDisposable
{

    private Cursor _oldCursor = Cursors.Arrow;
    private bool disposedValue = false;

    public LongOperation()
    {

        //salva il valore corrente

        this.OldCursor = Cursor.Current;

        //Imposta cursore di attesa

        Cursor.Current = Cursors.WaitCursor;
    }

    /// <summary>
    /// Riferimento al valore precedente
    /// </summary>

    public Cursor OldCursor
    {
        get { return _oldCursor; }

        set { _oldCursor = value; }
    }

    void IDisposable.Dispose()
    {

        Dispose(true);
        GC.SuppressFinalize(this);
    }

    private void Dispose(bool disposing)
    {

        // Check to see if Dispose has already been called.

        if (!this.disposedValue)
        {

            // If disposing equals true, dispose all managed
            // and unmanaged resources.

            if (disposing)
            {
                    //Ripristina valore precedente

                    Cursor.Current = this.OldCursor;
                    this.OldCursor.Dispose();
            }

            // Note disposing has been done.
            disposedValue = true;
        }
    }

}

Come potete notare è una classe molto semplice: nel costruttore viene impostato il WaitCursor e salvato il valore corrente. Nella fase di dispose invece viene ripristinato il valore precedente.

Tutto ciò è stato fatto per consentirci di implementare la gestione del cursore di attesa attraverso lo statement using, rendendo quindi il codice molto più leggibile:

using (LongOperation objLongOp = new LongOperation())
{

    // ...

    System.Threading.Thread.Sleep(2000);

    // ...
}

Avendo utilizzato lo statement using siamo certi che la dispose verrà richiamata sempre, quindi non dobbiamo preoccuparci di gestire il ripristino del cursore in seguito ad eventuali errori.