Dopo aver visto nella prima parte alcuni aspetti di questa classe e le varie proprietà e metodi utilizzati, qui https://www.iprogrammatori.it/articoli/microsoft-net-framework/art_c-utilizzo-della-nuova-classe-o-taskdialog-net-50-parte-1_1732.aspx l’articolo della prima parte. Vedremo in questa seconda ed ultima parte altri utilizzi che possono rendere la creazione di applicazioni più professionali e soprattutto semplificare lo sviluppo.
Riprendiamo il progetto precedente nel quale sono presenti una serie di pulsanti sulla form, con il quale per ogni pulsante faremo vedere i vari utilizzi.
Figura 1 – La form con la serie di pulsanti.
Stesura del codice
Riprendiamo dalla seconda riga di pulsanti, quella in basso, in particolare facciamo doppio click sul pulsante che ha la dicitura “Progress Bar”, in modo che passiamo in visualizzazione codice.
In questo esempio vedremo come applicare alla classe TaskDialogPage, una barra di progressione, tramite la classe “TaskDialogProgressBar” con il quale applicare al messaggio l’animazione.
Qui di seguito il codice delle suddette operazioni
C#
private void BtnProgressBar_Click(object sender, EventArgs e)
{
const string testo = "Chiusura tra {0} secondi...";
int SecondiRimanenti = 50;
var RiavviaButton = new TaskDialogButton("&Riavvia");
var cancelButton = TaskDialogButton.Cancel;
var page = new TaskDialogPage()
{
Heading = "Intestazione",
Text = string.Format(testo, (SecondiRimanenti + 9) / 10),
//Visualizzo l'icona della form, ma posso mettere altre icone.
Icon = new TaskDialogIcon(this.Icon),
ProgressBar = new TaskDialogProgressBar()
{
State = TaskDialogProgressBarState.Paused
},
Buttons =
{
RiavviaButton,
cancelButton
}
};
using (var timer = new Timer()
{
Enabled = true,
Interval = 100
})
{
timer.Tick += (s, e) =>
{
SecondiRimanenti--;
if (SecondiRimanenti > 0)
{
//Aggiorno la barra
page.Text = string.Format(testo, (SecondiRimanenti + 9) / 10);
page.ProgressBar.Value = 100 - SecondiRimanenti * 2;
}
else
{
//Invoco il click del pulsante riavvia al termine del caricamento della progress bar
timer.Enabled = false;
RiavviaButton.PerformClick();
}
};
TaskDialogButton result = TaskDialog.ShowDialog(this, page);
if (result == RiavviaButton)
MessageBox.Show("Riavviato.");
else
MessageBox.Show("Annullato.");
}
}
Come si è visto dal codice precedente, si fa uso anche della classe timer per aggiornare ogni tot secondi l’avanzamento della barra.
Il risultato sarà simile come quello mostrato in figura 2.
Figura 2 – il risultato del messaggio
Ritorniamo in visualizzazione grafica, e facciamo doppio click sul pulsante che riporta la dicitura “Multipla Pagina” in questo modo passiamo in visualizzazione codice nell’evento click del pulsante.
In questo pulsante verranno utilizzate varie classi per permettere una navigazione su più pagine. In particolare, si interagisce con l’utente in maniera che prosegue per tre passaggi (step) dove nella prima pagina, può continuare solo nel momento in cui farà click sul controllo di tipo “Checkbox, dopo il click sul controllo “checkBox” verrà abilitato un pulsante che permetterà di proseguire (figura 3).
Figura 3 – Il primo messaggio con il quale la check abilitato il pulsante “Si per continuare”.
Nella finestra successiva una pagina con barra di progressione con il quale ci sarà un pulsante disabilitato (figura 4).
Figura 4 - La seconda pagina con la barra di progressione
Al completamento della “Progress Bar”, verrà aperta una finestra con il pulsante di navigazione (figura 5).
Figura 5 – La terza ed ultima pagina con il pulsante di tipo collegamento
Qui di seguito il codice delle suddette operazioni.
C#
private void BtnMultiPage_Click(object sender, EventArgs e)
{
// Imposto il pulsante si come disabilitato
var ButtonYes = TaskDialogButton.Yes;
ButtonYes.Enabled = false;
ButtonYes.AllowCloseDialog = false;
var initialPage = new TaskDialogPage()
{
Caption = "Titolo applicazione",
Heading = "Intestazione - Come vuoi procedere?",
Text = "Sei sicuro di procedere?\n\n\n Testo a capo!",
Icon = TaskDialogIcon.ShieldWarningYellowBar, //Stile della pagina,
AllowCancel = true,
//Possibilità di minimazziare
AllowMinimize = true,
Verification = new TaskDialogVerificationCheckBox()
{
Text = "Scelta di default"
},
Buttons =
{
TaskDialogButton.No,
ButtonYes
},
DefaultButton = TaskDialogButton.No
};
// Creo un pulsante disabilitato nella pagina, perchè altrimenti mette uno di default che chiude la finestra.
var PulsanteDisabilitato = TaskDialogButton.Close;
PulsanteDisabilitato.Enabled = false;
var ProgressPage = new TaskDialogPage()
{
Caption = "Titolo applicazione",
Heading = "Operazione incorso........",
Text = "Testo - operazione in corso.",
Icon = TaskDialogIcon.Information,
AllowMinimize = true,
ProgressBar = new TaskDialogProgressBar()
{
State = TaskDialogProgressBarState.Marquee
},
Expander = new TaskDialogExpander()
{
Text = "Avvio......",
Position = TaskDialogExpanderPosition.AfterFootnote
},
Buttons =
{
PulsanteDisabilitato
}
};
// Viene aggiunto un pulsante per intercettare la chiusura della pagina.
var PulsanteDisabilitatoPerEvitareChiusura = TaskDialogButton.Cancel;
PulsanteDisabilitatoPerEvitareChiusura.Visible = false;
PulsanteDisabilitatoPerEvitareChiusura.AllowCloseDialog = false;
ProgressPage.Buttons.Add(PulsanteDisabilitatoPerEvitareChiusura);
var UltimaPage = new TaskDialogPage()
{
Caption = "Titolo Pagina Ultima Pagina",
Heading = "Testo",
Text = "Tutte le azioni sono terminate.",
Icon = TaskDialogIcon.ShieldSuccessGreenBar,
AllowMinimize = true,
Buttons =
{
TaskDialogButton.Close
}
};
TaskDialogButton VisualizzaButton = new TaskDialogCommandLinkButton("&Visualizza");
UltimaPage.Buttons.Add(VisualizzaButton);
//Abilito il pulsante di "Si" solo dopo aver selezionato il checkbox
TaskDialogVerificationCheckBox checkBox = initialPage.Verification;
checkBox.CheckedChanged += (sender, e) =>
{
ButtonYes.Enabled = checkBox.Checked;
};
//Navigo nella seconda pagina, al click del pulsante SI
ButtonYes.Click += (sender, e) =>
{
//Pagina relativa alla barra di avanzamento
initialPage.Navigate(ProgressPage);
};
// Simulo le operazioni che andranno fatte nella progress bar
ProgressPage.Created += async (s, e) =>
{
// Eseguo il caricamento della progressBar.
var progressBar = ProgressPage.ProgressBar;
await foreach (int ValoreProgressivo in SimulazioneCaricamentoProgressivoBarraAsync())
{
// Al primo avvio cambio lo stato
if (progressBar.State == TaskDialogProgressBarState.Marquee)
progressBar.State = TaskDialogProgressBarState.Normal;
progressBar.Value = ValoreProgressivo;
ProgressPage.Expander.Text = $"Avanzamento: {ValoreProgressivo} %";
}
//Al termine del caricamento della barra passo alla pagina successiva, al completamento 100%
ProgressPage.Navigate(UltimaPage);
};
//Visualizzo l'ultima pagina e verifico il pulsante selezionato
TaskDialogButton result = TaskDialog.ShowDialog(initialPage);
if (result == VisualizzaButton)
{
MessageBox.Show("Pulsante Visualizza");
}
static async IAsyncEnumerable<int> SimulazioneCaricamentoProgressivoBarraAsync()
{
//Attesa
await Task.Delay(2800);
for (int Conta = 0; Conta <= 100; Conta += 4)
{
yield return Conta;
await Task.Delay(200);
}
}
}
Passiamo in visualizzazione grafica per continuare a scrivere altri aspetti di utilizzo della classe per la gestione di messaggi a video in ambito avanzato.
Facciamo click sul pulsante con la dicitura “Esecuzione Amministratore” in maniera che passiamo in visualizzazione codice, ed in particolar modo nell’evento click del pulsante.
In questo pulsante viene visualizzato un messaggio a video con il quale tramite il pulsante di tipo “Navigazione” viene eseguito il prompt dei comandi di Windows in modalità “amministratore”.
Con la classe ProcessStartInfo viene eseguito il programma di prompt in modalità amministratore, il tutto invocando dal click del pulsante di tipo “TaskDialogCommandLinkButton”.
Qui di seguito il codice delle suddette operazioni.
C#
private void BtnAmministratore_Click(object sender, EventArgs e)
{
var pageAmministratore = new TaskDialogPage()
{
Heading = "Titolo - Esecuzione modalità amministratore",
Text = "Eseguire il programma in modalità amministratore",
Icon = TaskDialogIcon.ShieldSuccessGreenBar,
Buttons =
{
TaskDialogButton.Close
}
};
var EseguiButton = new TaskDialogCommandLinkButton("&Esegui");
pageAmministratore.Buttons.Add(EseguiButton);
EseguiButton.ShowShieldIcon = true;
EseguiButton.Click += (s, e) =>
{
EseguiButton.AllowCloseDialog = true;
EseguiButton.Enabled = false;
//Esegue in modalità amministratore il prompt dei comandi
var processPrompt = new ProcessStartInfo("cmd.exe", "/k echo testo, testo inserito nel prompt.")
{
UseShellExecute = true,
Verb = "runas"
};
try
{
Process.Start(processPrompt)?.Dispose();
}
catch (Win32Exception ex) when (ex.NativeErrorCode == 1223)
{
//Gestione dell'errore
EseguiButton.AllowCloseDialog = false;
EseguiButton.Enabled = true;
return;
}
};
TaskDialog.ShowDialog(this, pageAmministratore);
}
Ora non resta che eseguire il pulsante ed il risultato sarà come la figura 6.
Figura 6 – La pagina che apre in modalità amministratore il prompt
Siamo giunti quasi a conclusione dell’articolo, non ci resta che scrivere il codice per la gestione degli eventi che la classe TaskDialogPage offre con i suoi vari controlli.
Ritorniamo in modalità grafica, e facciamo click sull’ultimo pulsante, quello con la dicitura “Eventi” in modo che passiamo in visualizzazione codice nell’evento click del pulsante.
Questo ultimo frammento di codice fornisce vari esempi di codice dell’utilizzo degli eventi che si possono verificare nell’utilizzo della classe “TaskDialogPage” con i vari controlli che si possono inserire ed in quelli della classe (creazione, chiusura, etc).
Qui di seguito il frammento di codice delle suddette operazioni
C#
private void BtnEventi_Click(object sender, EventArgs e)
{
var pagePrincipale = new TaskDialogPage()
{
Caption = Text,
Heading = "Eventi",
Text = "Dimostrazioni eventi",
};
pagePrincipale.Created += (s, e) => MessageBox.Show("Creazione Pagina principale");
pagePrincipale.Destroyed += (s, e) => MessageBox.Show("Chiusura dopo ok della pagina principale");
pagePrincipale.HelpRequest += (s, e) => MessageBox.Show("Click pulsante Help della Pagina principale ");
pagePrincipale.Expander = new TaskDialogExpander("Parte che si espande")
{
Position = TaskDialogExpanderPosition.AfterFootnote
};
pagePrincipale.Expander.ExpandedChanged += (s, e) => MessageBox.Show("Evento ExpandedChanged: " + pagePrincipale.Expander.Expanded);
var buttonOK = TaskDialogButton.OK;
var buttonHelp = TaskDialogButton.Help;
var buttonChiudi = new TaskDialogCommandLinkButton("&Chiusura", allowCloseDialog: false);
var buttonShowInnerDialog = new TaskDialogCommandLinkButton("&Apri Task Dialog", "(con successiva chiusura)");
var buttonNavigaPaginaSecondaria = new TaskDialogCommandLinkButton("&Naviga Pagina Secondaria", allowCloseDialog: false);
pagePrincipale.Buttons.Add(buttonOK);
pagePrincipale.Buttons.Add(buttonHelp);
pagePrincipale.Buttons.Add(buttonChiudi);
pagePrincipale.Buttons.Add(buttonShowInnerDialog);
pagePrincipale.Buttons.Add(buttonNavigaPaginaSecondaria);
buttonOK.Click += (s, e) => MessageBox.Show($"Pulsante '{s}' Click");
buttonHelp.Click += (s, e) => MessageBox.Show($"Pulsante '{s}' Click");
buttonChiudi.Click += (s, e) =>
{
MessageBox.Show($"Pulsante '{s}' Click");
};
buttonShowInnerDialog.Click += (s, e) =>
{
MessageBox.Show($"Pulsante '{s}' Click");
TaskDialog.ShowDialog(new TaskDialogPage()
{
Text = "Testo Task Dialog"
});
MessageBox.Show($"Pulsante dopo ShowDialog '{s}' Click");
};
buttonNavigaPaginaSecondaria.Click += (s, e) =>
{
MessageBox.Show($"Evento click pulsante '{s}' ");
//Apro una nuova pagina
var pageSecondaria = new TaskDialogPage()
{
Heading = "Pagina secondaria.",
Buttons =
{
TaskDialogButton.Close
}
};
pageSecondaria.Created += (s, e) => MessageBox.Show("Evento pagina secondaria creazione ");
pageSecondaria.Destroyed += (s, e) => MessageBox.Show("Evento pagina secondaria di chiusura");
pagePrincipale.Navigate(pageSecondaria);
};
pagePrincipale.Verification = new TaskDialogVerificationCheckBox("&Controllo checkbox messo in basso");
pagePrincipale.Verification.CheckedChanged += (s, e) => MessageBox.Show("Evento CheckedChanged del check di verifica: " + pagePrincipale.Verification.Checked);
var radioButton1 = pagePrincipale.RadioButtons.Add("Radi&oButton 1");
var radioButton2 = pagePrincipale.RadioButtons.Add("RadioB&utton 2");
radioButton1.CheckedChanged += (s, e) => MessageBox.Show("Evento CheckedChanged del RadioButton1: " + radioButton1.Checked);
radioButton2.CheckedChanged += (s, e) => MessageBox.Show("Evento CheckedChanged dek RadioButton2: " + radioButton2.Checked);
var dialogResult = TaskDialog.ShowDialog(pagePrincipale);
MessageBox.Show("Visualizza risultato Task Dialog della pagina principale: " + dialogResult);
}
Il risultato sarà il tutto come illustrato in figura 7
Figura 7 – Esempio di eventi per i vari controlli
Conclusioni
L’articolo ha fornito una panoramica completo dell’utilizzo della nuova classe per la visualizzazione dei messaggi a video, standard di quelli di Windows, fornendo al lettore i vari utilizzi e le potenzialità offerte di questa classe.
Con il Framework 5.0 le potenzialità offerte sono tante, e tra queste anche nuove classi, come in questo caso per la classe “TaskDialogPage”.
L’utilizzo di questa classe, come anche l’articolo è per applicazioni di tipo “Windows Application” e con Visual Studio 2019 e Framework 5.0.