Si riporta l'articolo scritto per il sito https://www.iprogrammatori.it/articoli/microsoft-net-framework/art_c-utilizzo-della-nuova-classe-taskdialogpage-net-50-parte-2_1735.aspx
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.
Post
Le opere pubblicate in questo blog sono sotto la licenza Creative Commons. Attribuzione- No commerciale e no derivate.
