Gestire il controllo ProgressBar in un thread separato

Spesso capita che si vorrebbe mostrare un ProgressBar all'interno della nostra applicazione il problema è che non sempre è possibile gestire il controllo e far proseguire al nostro programma il suo normale lavoro.

Questo esempio mostra appunto come far apparire e gestire il controllo ProgressBar in un altro thread.

Il progetto è suddiviso in due parti, Form principale (MainForm) e Form di gestione ProgressBar (ProgressBarForm).

MainForm

La form principale genera un nuovo Thread e richiama su questo ProgressBar

void EseguiButtonClick(object sender, EventArgs e)

{

       int cicli;
       if (!int.TryParse(cicliTextBox.Text,out cicli))
             cicli = 20;
       ShowProgressBar();
      // facciamo qualche cosa
       for (int i = 0; i < cicli; ++i)
       {
             // mettiamo in pausa altrimenti non si vede niente
             System.Threading.Thread.Sleep(1000);

       }
       //Richiama il metodo di ProgressBarForm che lo fa chiudere
       this.progressBarForm.StopMessagePumpAndClose();
}
/// <summary>
/// Questo metodo genera un nuovo thread e richiama
/// CreateProgressWindowAndShow mettendolo in background
/// </summary>
private void ShowProgressBar()
{
     Thread t = new Thread(new ThreadStart(CreateProgressWindowAndShow));
      t.IsBackground = true;
      t.Start();
}
/// <summary>
/// Questo metodo richiama ProgressBarForm in un thread autonomo
/// usando Application.Run
/// </summary>

private void CreateProgressWindowAndShow()
{
    this.progressBarForm = new ProgressBarForm();
    Application.Run(this.progressBarForm);
}

 

ProgressBarForm

La form secondaria

/// <summary>
/// Utilizzato per chiudere la form dall'esterno

/// </summary>

public void StopMessagePumpAndClose()
{
      if (this.InvokeRequired)
      {
             this.Invoke(new MethodInvoker(StopMessagePumpAndClose));     

      }
      else
      {
             this.Close();
      }
}

 

Progetto di esempio C#

Progetto di esempio VB.NET

Windows Vista - RDP OCX Funziona dopo l'installazione del SP1

Per chi ha Windows Vista e ha, come io avevo, il problema di collegarsi ad un terminal server via Internet Explorer comunico la bella notizia che dopo l'installazione del SP1 (beta) che il collegamento ora funziona e non dà più come prima una segnalazione di "oggetti non validi nella pagina".

Dynamics NAV - Testare l'attributo DataPerCompany

Tempo fa ho fatto delle prove per vedere se era possibile testare su Dynamics l'attributo DataPerCompany, attributo che come è noto distingue le tabelle "per società" da quelle comuni a tutte le società.

E' una impostazione che si può inserire sulle proprietà della tabella, a seconda dell'attributo è presente e gestito un oggetto TableData per società oppure un solo oggetto TableData per tutte le società.

Testando appunto il campo "Company Name" della table Object ricercata con l'ID della Table che si vuole interrogare se è restituito un valore vuoto su Company Name la tabella ha DataPerCompany a False.

 

Codice sull trigger "OnPush" del CommandButton "verifica"

oggetto.SETRANGE(Type,oggetto.Type::TableData);
oggetto.SETRANGE(Name,"Nome Tabella");
IF oggetto.FINDFIRST THEN;
"Descrizione Società" := oggetto."Company Name";

Variabili locali:
oggetto di tipo Record -> Object

Variabili Globali

"Nome Tabella",Text50
"Descrizione Società",Text50>

La form ovviamente non è collegata a nessun Data Source

Se qualcuno ha qualche cosa di più "furbo" del mio esempio si faccia avanti!

Serializzazione e Deserializzazione con C# e VB.NET

La serializzazione è l'operazione di generazione di uno stream  (MemoryStream) contenente una immagine in bytes della classe serializzata.
Lo stream può essere utilizzato successivamente per la scrittura di un file fisico o per la trasmissione in rete.
La Deserializzazione è l'operazione contraria, partendo da un backup della classe serializzata si ottiene uno stream contenente l'immagine della classe e da questo la classe stessa.
La classe da serializzare deve essere decorata con l'attributo "Serializable"

C#
[Serializable]

VB.NET
<Serializable()>

Di seguito la classe C# che verrà serializzata, la corrispondente classe VBNET si può trovare nell'esempio allegato

/*
 * Creato da SharpDevelop.
 * Utente: Luciano
 * Data: 14/10/2007
 * Ora: 13.45
 *
 */

using System;
using System.Runtime;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Serialization.Formatters.Binary;
using System.Drawing;
using System.IO;

namespace SerializeCs
{

       /// <summary>
       /// Esempio di serializzazione
       /// Definizione una classe "Serializza"
       /// Si decora la classe l'attributo [Serializable] (obbligatorio per i nostri scopi)
       /// </summary>

       [Serializable]
       public class Serializza
       {
             // definizione membri privati
             private int mIntero;
             private string mTesto;
             private DateTime mDataOra;
             private decimal mDecimale;
             private bool mBooleano;
             private Image mImmagine;           

             public Serializza()
             {
             }

             #region Proprietà
             public int Intero
             {
                    get
                    {
                          return mIntero;
                    }
                    set
                    {
                          mIntero = value;
                    }
             }
             public string Testo
             {
                    get
                    {
                          return mTesto;
                    }
                    set
                    {
                          mTesto = value;
                    }
             }
              public DateTime DataOra
             {
                    get
                    {
                          return mDataOra;
                    }
                    set
                    {
                          mDataOra = value;
                    }
             }
             public decimal Decimale
             {
                    get
                    {
                          return mDecimale;
                    }
                    set
                    {
                          mDecimale = value;
                    }
             }
             public bool Booleano
             {
                    get
                    {
                          return mBooleano;
                    }
                    set
                    {
                          mBooleano = value;
                    }
             }
             public Image Immagine
             {
                    get
                    {
                          return mImmagine;
                    }
                    set
                    {
                          mImmagine = value;
                    }
             }
             #endregion
             #region Metodi serializzazione
             /// <summary>
             /// Serializzazione della classe Serializza
             /// </summary>
             /// <param name="serData">Classe da serializzare</param>
             /// <param name="NomeFile">Nome del file da generare</param>
             /// <returns>Operazione Eseguita/Non eseguita</returns>
             public bool Serializzazione(Serializza serData,string NomeFile)
             {
                    bool RetValue = true;
                    MemoryStream ms = new MemoryStream();
                    BinaryFormatter br = new BinaryFormatter();
                    using (FileStream fs = new FileStream(NomeFile, FileMode.OpenOrCreate))
                    {
                          try
                          {
                                 // il metodo Serialize di BinaryFormatter
                                 // restituisce nella variabile ms (MemoryStream)
                                 // la classe serializzata
                                 br.Serialize(ms,serData);
                                 // scriviamo sul file (FileStream fs)
                                 ms.WriteTo(fs);
                          }
                          catch (Exception ex)
                          {
                                 System.Diagnostics.Debug.WriteLine(ex.Message);
                                 System.Diagnostics.Debug.WriteLine(ex.StackTrace);
                                 RetValue = false;
                          }
                          finally
                          {
                                 fs.Close();
                          }                      

                    }
                    return RetValue;
             }

             /// <summary>
             /// Deserializzazione per la classe Serializza
             /// </summary>
             /// <param name="NomeFile"></param>
             /// <returns></returns>
             public Serializza DeSerializzazione(string NomeFile)
             {
                    using (FileStream fs = new FileStream(NomeFile, FileMode.Open))
                    {
                          BinaryFormatter bf = new BinaryFormatter();
                          try
                          {
                                 fs.Seek(0, SeekOrigin.Begin);
                                 return (Serializza) bf.Deserialize(fs);
                          }
                          catch
                          {
                                 return null;
                          }
                          finally
                          {
                                 fs.Close();
                          }
                    }
             }
             #endregion
       }
}

Ho messo alcuni tipi di oggetti nella classe "Serializza" per far vedere che la serializzazione "funziona".
BinaryFormatter Classe del framework che materialmente serializza o deserializza
FileStream Classe del framework dedicata alla generazione del flusso di dati in input o in output

Progetto di Esempio realizzato con C#
Progetto di esempio realizzato con VB.NET