using System.Threading;

namespace WindowsFormsApplication2
{
    public partial class Form1 : Form
    {
        private delegate void HandledOnLabelUpadte();
        Thread th;

        public Form1()
        {
            InitializeComponent();

            th = null;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            th = new Thread(Start);
            th.Start();
        }

        private void Start()
        {
            this.Invoke(new HandledOnLabelUpadte(OnLabelUpdate));
        }

        private void OnLabelUpdate()
        {
            label1.Text = "Hello!";
        }
    }
}

Al metodo Invoke è stato passato come parametro un delegato che punta alla funzione responsabile dell’aggiornamento del controllo Label.
Nulla di nuovo, questo è ciò che siamo abituati a fare quando intendiamo avere accesso sicuro ad un oggetto Control e suoi derivati.

E in WPF…?
Con l’ultima tecnologia rilasciata da Microsoft dedicata al nuovo tipo di sviluppo di user interface le cose cambiano appena in termini di codice, ma concettualmente non poi così tanto.
L’esempio precedente è qui riproposto in versione WPF Application:

using System.Threading;

namespace WpfApplication1
{
    public partial class Window1 : Window
    {
        private delegate void HandledOnLabelUpadte();
        Thread th;

        public Window1()
        {
            InitializeComponent();
            th = null;
        }

        private void button1_Click(object sender, RoutedEventArgs e)
        {
            th = new Thread(Start);
            th.Start();
        }

        private void Start()
        {
            this.Dispatcher.Invoke(new HandledOnLabelUpadte(OnLabelUpdate), System.Windows.Threading.DispatcherPriority.Normal);
        }

        private void OnLabelUpdate()
        {
            label1.Content = "Hello!";
        }
    }
}

In questo caso è stato utilizzato il metodo Invoke della classe Dispatcher, inserendo un parametro in più inerente la modalità di accesso all’operazione.

La classe Dispatcher offre diverse funzionalità e ci sarebbe molto altro da dire,
su MSDN è possibile trovare documentazione in abbondanza e di facile comprensione.

Condivi questo articolo:

Una di queste funzioni è sicuramente il copia/incolla di interi record, funzione che non è presente nella classe DataGridView.

Ma questo non vuol dire che non si possa implementare!

Prima di tutto dobbiamo impostare la proprietà ClipboardCopyMode del DataGridView:

this.dataGridView.ClipboardCopyMode = DataGridViewClipboardCopyMode.EnableWithoutHeaderText;

L’enumerazione DataGridViewClipboardCopyMode contiene quattro valori: con EnableWithoutHeaderText è possibile copiare negli Appunti i valori di testo delle celle selezionate. Il testo dell’intestazione non viene incluso.

Andiamo ora a implementare i metodi Copia e Incolla.
Il metodo Copia è semplicissimo:

private void Copia()
{
    Clipboard.SetDataObject(this.dataGridView.GetClipboardContent());
}

Con questo codice viene copiato nella Clipboard, attraverso il metodo static Clipboard.SetDataObject, i dati che tornano dal metodo GetClipboardContent() della classe DataGridView. Dati che vengono formattati in base al valore della proprietà ClipboardCopyMode.

Purtroppo il metodo Incolla non è così immediato:

        private void Incolla()
        {
            char[] rowSplitter = { '\r', '\n' };
            char[] columnsSplitter = { '\t' };
            string[] campi;
            //Ottengo le informazioni contenute negli appunti
            string appunti = Clipboard.GetText();
            //Divido gli appunti in righe
            string[] righe = appunti.Split(rowSplitter, StringSplitOptions.RemoveEmptyEntries); 

            foreach (string str in righe)
            {
                //Divido la stringa in campi e aggiungo la riga del DataGridView
                campi = str.Split(columnsSplitter);
                if (campi.Length == 2)
                {
                    this.bindingSource.AddNew();
                    DataRowView rowView =
                            (DataRowView)this.bindingSource.Current; 

                    if (campi[3] == String.Empty)
                        rowView[5] = DBNull.Value;
                    else
                        rowView[5] = int.Parse(campi[3]); 

                    if (campi[4] == String.Empty)
                        rowView[4] = DBNull.Value;
                    else
                        rowView[4] = int.Parse(campi[4]);
                }
            }
        }

Il procedimento è però abbastanza semplice: prima di tutto otteniamo i dati presenti nella Clipboard attraverso il metodo statico Clipboard.GetText(). Quindi i dati così ottenuti vengono divisi prima in righe, splittandoli sui valori ‘\r’ ‘\n’, e in seguito vengono splittati in colonne (\t). I dati così ottenuti vengono inseriti nel controllo DataGridView.

A questo punto resta da implementare solo il ContextMenu che conterrà i menu Copia e Incolla con i rispettivi eventi Click che richiamano i metodi Copia e Incolla.

Per fare questo si deve prima aggiungere un ContextMenu al progetto e poi associarlo al controllo DataGridView intercettando l’evento RowContextMenuStripNeeded del DataGridView stesso:

        private void dataGridView_RowContextMenuStripNeeded(object sender, DataGridViewRowContextMenuStripNeededEventArgs e)
        {
            e.ContextMenuStrip = this.contextMenuCopiaIncolla;
        }

Praticamente, ogni volta che si preme col tasto destro sul DataGridView, viene generato l’evento RowContextMenuStripNeeded che imposta la proprietà e.ContextMenuStrip sul contextMenu che contiene i menu Copia e Incolla.

Questo codice è solo un esempio. Il metodo Incolla si può adattare in base alle esigenze: per esempio si può valorizzare la chiave primaria se presente, oppure si può decidere di includere nella ClipBoard anche l’intestazione delle colonne e quindi incollare tutto in Excel.

Condivi questo articolo:

Questo comportamento è dovuto da questa riga di codice contenuta nel metodo Main:

Application.Run(new Form1());

Cito MSDN:

Application.Run avvia l’esecuzione di un ciclo di messaggi dell’applicazione standard sul thread corrente.

Passando al metodo Run la MainForm, quando questa si chiude, il ciclo dei messaggi viene terminato. Il metodo statico Run però ha altri due overload, uno che non accetta parametri e uno che accetta un’istanza di ApplicationContext.Continuo a citare MSDN:

ApplicationContext specifica le informazioni contestuali relative a un thread dell’applicazione.

Andando a “giocare” con ApplicationContext possiamo evitare la chiusura del programma quando si chiude la MainForm, e far invece terminare l’esecuzione quando si chiude l’ultima Form ancora aperta.

Per fare questo dobbiamo creare una classe che eredita da AplicationContext (che non è sealed), e modificare il comportamento a nostro piacimento, quindi passare al metodo Run un’istanza della nostra ApplicationContext.

class MyApplicationContext : ApplicationContext    {

La classe MyApplicationContext eredita da ApplicationContext e contiene un campo privato, forms, che rappresenta il numero di form presenti nel programma. Questo campo è quindi impostato a 0 alla creazione dell’isatnza.

private int forms;
public MyApplicationContext()
{
      this.forms = 0;
}

Il metodo pubblico AggiungiForm serve per dire a MyApplicationContext che esiste un’altra Form. Si creano quindi dei gestori per gli eventi FormClosing e FormClosed della Form, si aumenta il contatore dei Form e si visualizza il form aggiunto.

public void AggiungiForm(Form form)
{
      form.FormClosed += new FormClosedEventHandler(form_FormClosed);
      form.FormClosing += new FormClosingEventHandler(form_FormClosing);
      this.forms++;
      form.Show();
}

void form_FormClosing(object sender, FormClosingEventArgs e)
{
      if (forms == 1)
      {
             if (MessageBox.Show("Chiudendo questa form uscirai dal programma, sei sicuro di voler uscire?", "Chiusura",
                   MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
                   e.Cancel = true;
      }
}
void form_FormClosed(object sender, FormClosedEventArgs e)
{
      this.forms--;
      if (forms == 0)
            ExitThread();
}

Alla generazione dell’evento FormClosing, si controlla se c’è una sola form(quindi l’unica che c’è, è quella che si sta chiudendo). Viene quindi visualizzata una MessageBox con la conferma della chiusura del form e quindi dell’uscita del programma.Quando il form viene chiuso, si decrementa il contatore dei forms e se il contatore è uguale a 0 si termina il programma.Questo è un semplice esempio, volendo si potrebbe ampliare questa classe, aggiungendo cose come la scrittura su log quando si chiude una form o altro, come il salvataggio delle impostazioni. Ecco come utilizzare la classe nel metodo Main:

internal static MyApplicationContext myAppContext;
[STAThread]
static void Main()
{
      Application.EnableVisualStyles();
      Application.SetCompatibleTextRenderingDefault(false);
      myAppContext = new MyApplicationContext();
      myAppContext.AggiungiForm(new Form1());
      Application.Run(myAppContext);
}

E infine, il codice che si deve eseguire per aggiungere un form:

Form f2 = new Form();
f2.Text = "Form2";
Program.myAppContext.AggiungiForm(f2);

Condivi questo articolo: