[C#] Windows Form, BackgroundWorker, Delegati e... Cross-Thread

[0rph3n]

Ciao a tutti,
sono entrato in un tunnel e non riesco a vedere la via d'uscita (molto probabilmente _anzi, quasi sicuramente_ per una mia visione distorta delle cose), ho quindi bisogno che qualcuno mi metta una bussola in mano e mi dica vai di la!

Premessa: sto sviluppando un programmino che si deve occupare di aggiornare le installazioni del software sviluppato dall'azienda per cui lavoro.
Non deve necessitare di intervento da parte dell'utente e quindi l'interfaccia grafica unicamente la funzione di presentare le informazioni circa lo stato dell'aggiornamento.
Dati i requisiti (assenza di input e operazioni che necessitano di interfaccia grafica) e considerandolo un software semplice da sviluppare ho pensato che fosse il candidato ideale a diventare un banco prova.
Venendo al dunque, vorrei riuscire a strutturarlo in modo che la logica non dipenda in nessun modo dall'interfaccia.

Ora come ora per aggiornare l'interfaccia grafica ho preso spunto dal pattern observer.
Sono ancora in una fase sperimentale, comunque ora l'applicazione è composta da:

• LogManager: memorizza i messaggi di log ed invoca un delegato
  

  public class LogManager
  {
      private String log;
      private NotificaModificaLog notificaModifica;
  
      public NotificaModificaLog Notifica
      {
          get { return this.notificaModifica; }
          set { this.notificaModifica = value; }
      }
  
      public void Log(String messaggio)
      {
          log += "\n";
          log += messaggio;
          this.notificaModifica.Invoke(this, messaggio);
      }
  
      public void Salva()
      {
          ...
      }
  }

• NavigatoreFasiAggiornamento: restituisce un istanza della classe che implementa la logica per la fase successiva dell'aggiornamento
  

  public class NavigatoreFasiAggiornamento
  {
      private System.Collections.Generic.Dictionary<Int32, Type> fasi = new Dictionary<int,Type>();
      private Int32 indiceFaseCorrente;
  
      public NavigatoreFasiAggiornamento()
      {
          this.fasi.Add(1, Type.GetType("SkyStoreUpdater.Operazioni.VerificaDisponibilita"));
          this.fasi.Add(2, Type.GetType("SkyStoreUpdater.Operazioni.DownloadAggiornamento"));
          this.fasi.Add(3, Type.GetType("SkyStoreUpdater.Operazioni.VerificaIntegrita"));
          this.fasi.Add(4, Type.GetType("SkyStoreUpdater.Operazioni.Aggiornamento"));
  
          this.indiceFaseCorrente = 0;
      }
  
      public Operazione ProssimaFase()
      {
          this.indiceFaseCorrente += 1;
          Type tipoOperazione;
          tipoOperazione = this.fasi[this.indiceFaseCorrente];
          return (Operazione)Activator.CreateInstance(tipoOperazione);
      }
  }

• Operazione
  

  public abstract class Operazione
  {
      protected LogManager logger;
  
      public LogManager Logger
      {
          set { this.logger = value; }
      }
  
      public abstract void Esegui(object sender, DoWorkEventArgs e);
  }

• VerificaDisponibilita: dovrebbe essere la prima fase dell'aggiornamento ma in questo momento è unicamente una classe di test per il giro dei delegate del LogManager
  

  public class VerificaDisponibilita : Operazione
  {
      public override void Esegui(object sender, DoWorkEventArgs e)
      {
          Int32 indice;
          for (indice = 1; indice <= 1000; ++indice)
          {
              this.logger.Log(indice.ToString());
          }
      }
  }

• GestoreAggiornamento: esegue le fasi dell'aggiornamento tramite un BackgroundWorker
  

  public class GestoreAggiornamento
  {
      private BackgroundWorker worker;
  
      private NavigatoreFasiAggiornamento navigatoreFasiAggiornamento;
      private LogManager logger;
  
      public GestoreAggiornamento()
      {
          this.worker = new BackgroundWorker();
          this.worker.WorkerReportsProgress = true;
  
          this.navigatoreFasiAggiornamento = new NavigatoreFasiAggiornamento();
      }
  
      public LogManager Logger
      {
          set { this.logger = value; }
      }
  
      public void Esegui()
      {
          this.PassaAFaseSuccessiva();
          this.worker.RunWorkerAsync();
      }
  
      private void PassaAFaseSuccessiva()
      {
          Operazione fase = this.navigatoreFasiAggiornamento.ProssimaFase();
          fase.Logger = this.logger;
          this.worker.DoWork += new DoWorkEventHandler(fase.Esegui);
      }
  }

• form
  

  public partial class updaterMain : Form
  {
      public updaterMain()
      {
          InitializeComponent();
      }
  
      public void AggiornaPercentuale(object sender, ProgressChangedEventArgs e)
      {
          this.avanzamentoFase.Value = e.ProgressPercentage;
      }
  
      public void AggiornaLog(LogManager sender, String messaggio)
      {
          this.textLog.Text += messaggio;
      }
  }

• punto di ingresso del programma
  

  [STAThread]
  static void Main()
  {
      Application.EnableVisualStyles();
      Application.SetCompatibleTextRenderingDefault(false);
  
      updaterMain formMain = new updaterMain();
  
      LogManager logger = new LogManager();
      logger.Notifica = new NotificaModificaLog(formMain.AggiornaLog);
  
      GestoreAggiornamento gestore = new GestoreAggiornamento();
      gestore.Logger = logger;
      gestore.Esegui();
  
      Application.Run(formMain);
  }

Ora...senza neanche star la a cercare di sicuro ci sarà qualcosa di sbagliato!
...ed infatti SE la seconda espressione del ciclo for nel metodo Esegui della classe VerificaDisponibilita è "indice <= 10000" viene lanciata SEMPRE una

InvalidOperationException:
Operazione cross-thread non valida: è stato eseguito l'accesso al controllo 'textLog' da un thread diverso da quello da cui è stata eseguita la creazione.

mentre se è "indice <= 1000" la stessa eccezione viene lanciata con una frequenza che ad occhio sembra casuale OPPURE se clicco con il mouse su uno dei controlli del form.

Cercando un po' ho visto che per aggiornare un controllo dell'interfaccia utente da un thread diverso da quello che lo ha generato si deve chiamare il metodo Invoke del controllo passando come parametro un delegato alla funzione che dovrebbe appunto aggiornare il controllo.
Ma facendo così chi ora invoca il delegato dovrebbe avere un riferimento al form o quantomeno al controllo ed è ciò che io volevo evitare.

Qualche consiglio? (anche di design)

[gugoXX]

Non sono entrato nel merito del design.
Comunque nessuno dovrebbe invocare il delegate direttamente. Viene chiamata la funzione, che semplicmente sincronizzera' il thread con quello della form, (quando e se necessario).

Esempio: Dota tutti i tuoi controlli/form di un metodo come:
(PS: Lo puoi fare mediante partial class, oppure mediante Extension Method)

private T SafeThreadExecutor<T>(Func<T> CodeToBeInvoked)
{
    if (InvokeRequired) return (T)Invoke(CodeToBeInvoked);
    else return CodeToBeInvoked();
}

E lo userai semplicemente, quando serve, cosi',

... 
MioControllo.SafeThreadExecutor( () => {
    AggiornoBarra();
    SpostoSubContollo();
    CambioColore();
});

ovvero non eseguirai il codice di "textLog" direttamente, ma lo passerai alla funzione SafeThreadExecutor, mediante funzionale.
(Che e' poi un delegate, ma di scrittura un po' piu' compatta)
Nota che questa funzione puo' ritornare un valore, che puo' essere eventualmente utilizzato dal chiamante, il quale stara' in attesa fino a che il thread della finestra non avra' finito (per questo si parla di sincronizzare)