[C# + .NET] Control e Multithreading

[Bonfo]

Ciao a tutti.
E' da un bel po' che non mi diletto con la programmazione .NET quindi sono un bel po' a secco.
Non mi aspetto una risposta esaustiva, ma almeno fonti e documentazione o altri forum su cui domandare!

Veniamo al punto.
Mi creo una bella Form. Dodo di che alla notifica dell'evento Load avvio un thread.
Se nel delegato del thread uso un metodo mi cucco una eccezione perchè il CLR dice che non posso accedere ad un oggetto Control da un altro thread diverso da quello che l'ha creato.

Ok. Mi faccio il mio bel delegato per il metodo in questione e uso la Invoke().

Ora però mi da lo stesso errore se volgio accedere a una proprietà della Form. E qui per risolvere il probelma devo proprio fare un giro dell'oca!

Prima di tutto mi devo fare il metodo per accedere alla property:

private bool isFocused()
{
      return Focused;
}

poi mi devo creare il delegato (tipo e membro):

private delegate bool FormFocusDelegate();
private FormFocusDelegate focusDelegate;

....
focusDelegate = new FormFocusDelegate(isFocused);
....

ed infine all'interno del delegate del thread uso la invoke:

(bool) Invoke(focusDelegate)

Insomma, mi sembra una cosa troppo complicata per C#! Sicuramente c'è un metodo più semplice.

HELP!

[gugoXX]

E' la stessa cosa.
Non puoi accedere a metodi che abbiano a che fare con la parte visuale di una form (o un controllo) da parte di un thread diverso da quello della form ospitante.
La soluzione e' sempre quella del delegate.

Se invece stai usando un thread solo per temporizzare qualcosa che periodicamente deve essere fatto, ti consiglio l'uso del controllo Timer, che ha gia' scritto tutto il codice per te, e io tuo codice girerebbe gia' sotto il thread della finestra.

Altrimenti, questa e' la versione C#2.0 per quello che chiedi (se ho capito bene)

private Thread th = null;

// Nella load o dove ti serve
th = new Thread(new ThreadStart(ThreadBody));
            th.Start();
// se non altrimenti gestito
//    almeno nella FormClosing metterei la Join del Thread
...
...

private void ThreadBody()
{
    Thread.Sleep(5000);
    int mioval = THRoutine();
    MessageBox.Show(mioval.ToString());
}

// Esempio di una proprieta'/metodo che fa accesso ad un parametro della form
// E che ritornera' un intero
private delegate int IntDelegate();

private int THRoutine()
{
    if (InvokeRequired) return (int)Invoke(new IntDelegate(THRoutine));
    else
    {
        BackColor = Color.FromArgb(128, 200, 255);
        button1.Text = "PPPPRRR";
        return (int)BackColor.R + (int)BackColor.G + (int)BackColor.B;
    }
}

Con il C# 3.0 e' possibile fare qualcosa di un pelino piu' comodo.
Si potrebbe scrivere il seguente codice anche per C#2.0, ma e' tanto che non uso piu' le implicit delegate, dato che le Func sono cosi' comode...

private Thread th = null;

// Nella load o dove ti serve
th = new Thread(new ThreadStart(ThreadBody));
            th.Start();
// se non altrimenti gestito
//    almeno nella FormClosing metterei la Join del Thread
...
...
private void ThreadBody()
{
    Thread.Sleep(5000);
    int mioval = FormThreadExecutor<int>( () => {
                    BackColor = Color.FromArgb(128, 200, 255);
                    button1.Text = "PPPPRRR";
                    return (int)BackColor.R + (int)BackColor.G + (int)BackColor.B;
                });
    MessageBox.Show(mioval.ToString());
}        
            
private T FormThreadExecutor<T>(Func<T> CodeToBeInvoked)
{
    if (InvokeRequired) return (T)Invoke(CodeToBeInvoked);
    else return CodeToBeInvoked();
}

In questo modo il FormThreadExecutor e' scritto una volta sola, ritorna un parametro di tipo variabile, e si potranno scrivere tutti i codici da sincronizzare direttamente dentro il ThreadBody(Certo, se devi sincronizzare una cosa sola, allora voto per la soluzione C#2.0).
Oppure usando le extension e/o le partial class puoi scrivere questo FormThreadExecutor in una tua libreria, cosicche' tutte le tue soluzioni WinForm avranno questo metodo gia' pronto per l'uso.

[Bonfo]

Grazie mille. Risposta più che esauriente.