DataGridView da XML in C#

Il .NET Framework per certi versi è davvero ottimo.

Quello che vediamo oggi è come riempire una GridView da dati presi da un file XML.

Come potremo vedere, la cosa sarà molto semplice (soprattutto se non abbiamo pretese di personalizzazione); così semplice che neanche vi dirò com'è strutturato il file.

Ovviamente, in questo semplice esempio, verranno create tante colonne quanti sono i campi presenti nel file.

Quindi questo dipende anche dalle vostre esigenze.

Inoltre il progetto si basa su un Windows Form classico (l'ho preferito al WPF).

Bene, prima di tutto trasciniamo nella finestra un oggetto DataGridView.

wxPython Grid JSON

Negli articoli precedenti abbiamo visto come ottenere dati in formato JSON da un web service, e come creare una wxPython Grid.

Partendo da quegli articoli vediamo come riempire una Grid perndendo in dati in formato JSON.

Partiamo dalla classe che interroga il web service:

import httplib
import json

class Service(object):

    conn = None

    def __init__(self):
        self.conn = httplib.HTTPConnection("www.miosito.it")
        
    def listLogFile(self):
        self.conn.request(method = "GET", url = "/service/log.php", headers = { "Content-Type": "application/json" })
        res = self.conn.getresponse()
        data = json.loads(res.read())
        tabella = []
        for i in data:
            list = []
            list.append(i["nome"])
            list.append(i["data"])
            tabella.append(list)
        self.conn.close()
        return tabella
       

Fino a qua nulla di nuovo.

wxPython Grid

Oggi vediamo come usare il componente Grid in Python e wxPython.

Questo componente è la "classica" tabella, diviso in righe e colonne.

Vediamone un primo esempio:

import wx
import wx.grid as gridlib

class GridForm(wx.Frame):

    def __init__(self):
        wx.Frame.__init__(self, parent=None, title="Grid")
        panel = wx.Panel(self)
 
        g = gridlib.Grid(panel)
        g.CreateGrid(6, 6)
 
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(g, 1, wx.EXPAND)
        panel.SetSizer(sizer)
 
if __name__ == "__main__":
    app = wx.PySimpleApp()
    frame = GridForm().Show()
    app.MainLoop()

Prima importiamo le librerie che ci interessano.

Inizializiamo il Frame, aggiungiamo un Panel e sotto creiamo la nostra Grid.

Al metodo CreateGrid dobbiamo passargli il numero di righe e colonne.

Sotto avviamo la app.

Esportare DataSet in Excel

In un altro articolo ho spiegato come esportare una DataGridView in Excel.

Adesso vediamo come esportare un DataSet direttamente, in modo da renderlo indipendente dal componente dove visualiziamo i dati.

In questo caso, infatti, i dati vengono poi rappresentati su una pagina Asp.NET e il plugin jQuery DataTable, il che rende impossibile esportare i dati direttamente dal componente.

Dobbiamo quindi estrarli direttamente da un DataSet.

Prima di tutto dobbiamo avere un metodo che esegue la connessione e la query; tipo questo:

        public DataSet getSomething()
        {
            connection().Open();
            OdbcCommand cmd = new OdbcCommand();
            OdbcDataAdapter adapter = new OdbcDataAdapter();
            DataSet ds = new DataSet();
            cmd.CommandText = "SELECT * FROM somewhere";
            cmd.Connection = conn;
            adapter.SelectCommand = cmd;
            adapter.Fill(ds);
            ds.Dispose();
            conn.Close();
            return ds;
        }

Semplicemente ritorna un DataSet.

Esportare DataGridView in Excel

In un altro articolo abbiamo visto come esportare una DataGridView in formato TXT.

Ora vediamo come esportarla in formato Excel, sicuramente più comodo da visualizzare rispetto al TXT.

Prima di tutto nel nostro progetto dobbiamo aggiungere una referenza.

Cliccate col tasto destro sul progetto -> Aggiungi riferimento -> .NET -> Microsoft.Interop.Excel

A qusto punto ho aggiunto un Item nel menu con questo evento:

private void saveXLSToolStripMenuItem_Click(object sender, EventArgs e)
{
    DialogSalvaXls dlg = new DialogSalvaXls();
    dlg.dialog(dataGridViewEntrate);
}

Non faccio altro che lanciare un SaveFileDialog e passargli la DataGridView da esportare.

Per il SaveFileDialog potete guardare qua.

Stampare con C#

Mnetre stampare una JTable in Java è piuttosto semplice, stampare una DataGridView in C# non è così immediato.

Prima di tutto nel Windows Form aggiungete un oggetto PrintDocument.

Ve lo ritroverete in basso; selezionatelo e nelle proprietà impostate il DocumentName e tra gli eventi impostate l'evento PrintPage.

L'evento sarà una cosa del genere:

private void printDocument1_PrintPage(object sender, System.Drawing.Printing.PrintPageEventArgs e)
{
    Bitmap bm = new Bitmap(this.dataGridViewEntrate.Width, this.dataGridViewEntrate.Height);
    Rectangle rc = new Rectangle(0, 0, this.dataGridViewEntrate.Width, this.dataGridViewEntrate.Height);
    dataGridViewEntrate.DrawToBitmap(bm, rc);
    e.Graphics.DrawImage(bm, 0, 0);
}

In pratica definiamo l'area da stampare e trasformiano la DataGridView in una Bitmap.

Per fare le cose per bene aggiungiamo anche un oggetto PrintDialog e nelle proprietà impostiamo Document impostando printDocument1....(controllate anche le opzioni che sono interessanti).