0rph3n
13-01-2009, 16:22
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)
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)