Parseig d’XML amb C# i DOM (Mono)

Una de les guerres religioses més interessants que hi han hagut en els darrers temps en el món del programari lliure ha estat entre els partidaris i detractors de Mono.

Mono és una implementació lliure de .Net per a màquines GNU/Linux basada en l’estàndar ECMA. La batalla al voltant d’aques projecte és perquè part de les eines que s’han implementat podrien no respectar les llicències de Microsoft. Es tem que, en un moment donat, els de Redmond pordrien denunciar aquesta possible violació de llicències i provocar que tot allò que estigues desenvolupat a partir d’aquest programari no lliure de Mono quedés en una situació difícil.

Els defensors de Mono diuen que les parts conflictives són molt poques i estan ben localitzades i que programar sobre Mono no presenta perill.

No prendré partit. En tot cas, des del meu punt de vista, Mono ofereix una plataforma  alternativa als desenvolupadors de .Net. Una plataforma basada en programari i sistemes operatius lliures, amb l’extraordinari estalvi de cost de llicències que això suposa.

Per mi, doncs, Mono és una plataforma a tenir en compte pels desenvolupadors. I no només. Amb Mono sobre Linux i Apache es poden executar aplicacions  CMS com dotNetNuke, o  MojoPortal. EL trio Linux,Apache,Mono ofereix, doncs, una alternativa per al hosting amb ASP.

Mono ens porporciona eines tan interessants com els compiladors de C# i  VB.NET que poden compilar a Linux nadiu però també al bytecode del CLI i, per tant, poden produir executables aptes per Windows.

En aquest post presento com fer servir un fitxer XML com a fitxer de configuració.  NET no té, com Java, una classe per a fitxers de properties de Unix, ni fitxers .ini de Windows. És dir, fitxers amb files  nom=valor. La filosofia NET recomana fer servir XML per a les configuracions.

NET és eficient amb l’XML. Per als programadors de NET  provinents de Java l’anàlisi de fitxers XML té dos noms principals associats: DOM i SAX.

De forma molt resumida: DOM permet analitzar fitxers més aviat petits i es basa en carregar el fitxer en memòria i exposar-lo a les aplicacions com un arbre d’objectes que ens representen els elements i els atributs.

SAX, per la seva banda, és un parser que processa  un flux XML i que respon, amb funcions de callback, quan es produeixen determinats esdeveniments, per exemple l’aparició d’una etiqueta concreta o una ordre de processament. SAX és lleuger i  adequat per al processat de grans fluxos, o grans fitxers d’XML.

Doncs bé. L’API estàndar de SAX no està al framework de .NET. Existeix, això sí, una API pròpia que és, conceptualment, equivalent a SAX (diguem que el parseig basat en XmlTextReader). I també es pot trobar la implementació de SAX per a .NET, com una descàrrega externa.

En canvi, l’API estàndar DOM està implementada al framework de .NET. El que faré serà aprofitar l’API DOM de NET per a fer servir un fitxer  XML com a fitxer de configuració.

El fitxer XML és aquest:

<?xml version=”1.0″ encoding=”utf-8″ ?>
<!DOCTYPE claus> 
<claus>
<clau nom=”Nom1″ valor=”Valor1″ />
<clau nom=”Nom2″ valor=”Valor2″ />

</claus>

Primer de tot, amb el MonoDevelop (instal·lable des del Centre de programari de l’Ubuntu) crearé una nova Solució del tipus aplicació de consola amb  C#.
Afegeixo la referència System.Xml i creo dues classes C#

KeyValuePair és, com el seu nom indica, una estructura de dades clau-valor

using System;
using System.Collections.Generic;
using System.Text;

namespace provaproperties
{
    class KeyValuePair
    {
        string sKey;
        string sValue;

        public KeyValuePair(string sKey, string sValue)
        {
            this.sKey = sKey;
            this.sValue = sValue;
        }

        public string getKey()
        {
            return sKey;
        }

        public string getValue()
        {
            return sValue;
        }

    } // de la class
} // del namespace
La classe Config, carrega un fitxer XML de configuració, l’analitza amb XML i el fa servir per carregar parells nom valor en una classe de col·lecció ArrayList. A més, proporciona un mètode per obtenir un valor de la llista a partir d’una clau.

Un incís: el que acabo d’implementar aquí és un diccionari. NET proporciona la classe Dictionary a System.Collections.Generic. L’objectiu del post era presentar l’ús de DOM, no implementar un diccionari. Si el que ens cal és un diccionari, la millor opció, evidentment, és fer  servir la classe del framework.

La classe config:


using System;
using System.Collections;
using System.Collections.Generic;
using System.Xml;
using System.Text;

namespace provaproperties
{
    class Config
    {
        ArrayList arrKeyValuePairs = null;
       
        public static void Main (string[] args)
        {
            Console.WriteLine (“Anàlisi de fitxer de configuració”);
            Config cf = new Config(“./config.xml”);
            Console.WriteLine(“clau: Nom1; valor: {0}”, cf.getValue(“Nom1”));
            Console.WriteLine(“clau: Nom2; valor: {0}”, cf.getValue(“Nom2”));
            Console.WriteLine(“clau: Nom3; valor: {0}”, cf.getValue(“Nom3”));   
        }
       
       
        public Config(string sXmlConfigFile)
        {
            arrKeyValuePairs = new ArrayList();
           
            /* XML de configuracions
            * <?xml version=”1.0″ encoding=”utf-8″ ?>
            * <!DOCTYPE claus>
            * <claus>
            *   <clau nom=”Nom1″ valor=”Valor1″ />
            *   <clau nom=”Nom2″ valor=”Valor2″ />
            *   …
            * </claus>
            */

            string sClau = “”;
            string sValor = “”;
           
            // DOM parsing
            XmlDocument xdoc = new XmlDocument();
            xdoc.Load(sXmlConfigFile);
            XmlNodeList xnl = xdoc.GetElementsByTagName(“clau”);
            foreach (XmlNode node in xnl)
            {
                XmlAttributeCollection attrColl = node.Attributes;
                foreach( XmlAttribute attr in attrColl)
                {
                    string sName = attr.Name;
                    string sValue = attr.Value;

                    if (sName == “nom”)
                    {
                        sClau = sValue;
                    }

                    if (sName == “valor”)
                    {
                        sValor = sValue;
                    }
                }

                // afegeix les claus a l’Array
                arrKeyValuePairs.Add(new KeyValuePair(sClau, sValor));
            }
        }


        public string getValue(string sClau)
        {
            // si no el troba, torna “”.
           
            string sValue = “”;

            foreach (KeyValuePair item in arrKeyValuePairs)
            {
                if (item.getKey() == sClau)
                {
                    sValue = item.getValue();
                    break;
                }
            }
           
            return sValue;
        }
       
    } // de la class
}  // del namespace

I compilem. L’execució del programa proporciona l’efecte esperat:

albert@atenea:~/wk-mono/prova-properties/prova-properties/bin/Debug$ ./prova-properties.exe
Anàlisi de fitxer de configuració
clau: Nom1; valor: Valor1
clau: Nom2; valor: Valor2 
clau: Nom3; valor:

Encara un altre incís: si la intenció és fer servir l’XML com a fitxer de configuració mitjançant DOM, aleshores, el fet de carregar una ArrayList amb els parells nom valor resulta, si més no, redundant.

Una solució sense redundàncies seria crear un mètode que obtingués el valor corresponent a la clau cercada directament a partir del Document XML parsejat. Per exemple, una cosa com la següent. Un detall interessant, la doble iteració sobre els atributs. És necessària perquè l’ordre de la col·lecció d’atributs no està determinat i, si fes una sola passada, podria ser que el valor aparegués abans del nom, i no sabria identificar-lo. Vet aquí el codi:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Xml;
using System.Text;

namespace provaproperties
{
    class XmlConfig
    {
        XmlDocument xdoc = null;
       
        public static void Main (string[] args)
        {
            Console.WriteLine (“Anàlisi de fitxer de configuració – millorat”);
            Config cf = new Config(“./config.xml”);
            Console.WriteLine(“clau: Nom1; valor: {0}”, cf.getValue(“Nom1”));
            Console.WriteLine(“clau: Nom2; valor: {0}”, cf.getValue(“Nom2”));
            Console.WriteLine(“clau: Nom3; valor: {0}”, cf.getValue(“Nom3”));   
        }
       
       
        public XmlConfig(string sXmlConfigFile)
        {
           
            /* XML de configuracions
            * <?xml version=”1.0″ encoding=”utf-8″ ?>
            * <!DOCTYPE claus>
            * <claus>
            *   <clau nom=”Nom1″ valor=”Valor1″ />
            *   <clau nom=”Nom2″ valor=”Valor2″ />
            *   …
            * </claus>
            */
           
            // DOM parsing
            XmlDocument xdoc = new XmlDocument();
            xdoc.Load(sXmlConfigFile);
        }

        public string getValue(string sClau)
        {
            // si no el troba, torna “”.
            string sFoundValue = “”;

            // obté la llista de nodes
            XmlNodeList xnl = xdoc.GetElementsByTagName(“clau”);
           
            // itera pels nodes
            foreach (XmlNode node in xnl)
            {
                // obté els atributs del node
                XmlAttributeCollection attrColl = node.Attributes;
                Boolean boolTrobat = false;
               
                // itera pels atributs del node
                foreach( XmlAttribute attr in attrColl)
                {
                    // nom de l’atribut
                    string sName = attr.Name;
                    // valor de l’atribut
                    string sValue = attr.Value;

                    // si el nom de l’atribut és nom
                    if (sName == “nom”)
                    {
                        // aleshores, si el valor coincideix amb la clau buscada
                        if (sValue == sClau)
                        {
                            // és que l’ha trobat
                            boolTrobat = true;
                        }
                    }
                }
                   
                // si l’ha trobat, aleshores busca el valor
                if (boolTrobat) {
                    // itera pels atributs del node un altre cop
                    foreach( XmlAttribute attr in attrColl)
                    {
                        // nom de l’atribut
                        string sName = attr.Name;
                        // valor de l’atribut
                        string sValue = attr.Value;
   
                        // si el nom de l’atribut és valor
                        if (sName == “valor”)
                        {
                            // aleshores, ja el tenim
                            sFoundValue = sValue;
                            break;
                       
                        }
                    }
                }   
            } // del foreach
           
            return sFoundValue;
       
        } // del mètode       
    } // de la class
}  // del namespace

Com abans, compilem i executem. El resultat és l’esperat:

albert@atenea:~/wk-mono/prova-properties/prova-properties/bin/Debug$ ./prova-properties.exe
Anàlisi de fitxer de configuració – millorat
clau: Nom1; valor: Valor1
clau: Nom2; valor: Valor2
clau: Nom3; valor:

Anuncis

API C per a SQLite3

En aquest post presento un exemple de com fer servir l’API de C per a SQLite3 a Ubuntu 10.04.

L’API de C per a SQLite3 ens proporciona una interfície eficient per a programar aplicacions amb aquesta base de dades.

Per una banda crearé una base de dades nova. Fem servir l’SQLite Database Browser (es pot instal·lar des del Centre de Programari de l’Ubuntu).

Creo la ‘taula1’ amb tres columnes: id, del tipus integer; i valor i traduccio, les dues del tipus varchar.

Informo la taula amb algunes dades de prova:

Desenvolupo l’exemple fent servir la IDE Anjuta (si cal, es pot instal·lar des del centre de programari de l’Ubuntu). Creo un projecte C nou del tipus genèric (mínim).
Fins i tot sent un projecte “mínim” la quantitat de fitxers que genera Anjuta és important. Tanmateix, només ens caldrà modificar-ne dos: el main.c i el Makefile.am.

Li dono la ubicació del projecte i al fitxer main.c hi posem el següent codi


/*
 * main.c
 * Copyright (C) albert 2011 <stsoftlliure@gmail.com>
 *
 * c-sqlite is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * c-sqlite is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/&gt;.
 */

#include <stdio.h>
#include <sqlite3.h>
int main(void) {
    /* variables */
    sqlite3 *conn;
    sqlite3_stmt *stmtResultSet;
    int iError=0;
    int iComptador=0;
    const char *tail;
   
    /* obre  la connexió a la bd*/
    /* int sqlite3_open(
    /*     const char *filename,   /* Database filename (UTF-8) */
    /*     sqlite3 **ppDb          /* OUT: SQLite db handle */
    /* );
    /*****/
    iError = sqlite3_open(“/home/albert/databases/sqlite3/prova-sqlite2/prova2.db3”,
                          &conn);
    if (iError) {
        puts(“No pot obrir la base de dades”);
        exit(0);
    }
   
    /* crea una instrucció per a executar-la, en aquest cas un update */
    /* int sqlite3_exec(
    /*     sqlite3*,                                  /* An open database */
    /*     const char *sql,                           /* SQL to be evaluated */
    /*     int (*callback)(void*,int,char**,char**),  /* Callback function */
    /*     void *,                                    /* 1st argument to callback */
    /*     char **errmsg                              /* Error msg written here */
    /* );
    /*****/
    iError = sqlite3_exec(conn,
                          “update taula1 set traduccio=\’nova traducció\’ where id=5”,
                          0,0,0);
    if (iError) {
        puts(“Error en fer update”);
        exit(0);
    }
   
    /* fa una query i obté un “resultset” */
    /*
    /* int sqlite3_prepare_v2(
    /*     sqlite3 *db,            /* Database handle */
    /*    const char *zSql,       /* SQL statement, UTF-8 encoded */
    /*    int nByte,              /* Maximum length of zSql in bytes. */
    /*    sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
    /*    const char **pzTail     /* OUT: Pointer to unused portion of zSql */
    /* );
    /*****/
    iError = sqlite3_prepare_v2(conn,
                                “select id, valor, traduccio from taula1 order by id”,
                                1000,
                                &stmtResultSet,
                                &tail);
    if (iError != SQLITE_OK) {
        puts(“No pot obtenir dades”);
        exit(0);
    }
   
    puts(“—————————————“);
   
    /* mostra els resultats obtinguts iterant pas a pas pel pel “ResultSet” */
    /*
        int sqlite3_step(sqlite3_stmt*);
        After a prepared statement has been prepared using either sqlite3_prepare_v2() 
        this function must be called one or more times to evaluate the statement.
        If the SQL statement being executed returns any data,
        then SQLITE_ROW is returned each time a new row of data is ready
        for processing by the caller.
        The values may be accessed using the column access functions.
        sqlite3_step() is called again to retrieve the next row of data.
       
        Result Values From A Query:
        int sqlite3_column_int(sqlite3_stmt*, int iCol);
        const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
    */                   
    while(sqlite3_step(stmtResultSet) == SQLITE_ROW) {
        /* en la fila actual, obté els valors de les columnes */
        printf(“%d |”, sqlite3_column_int(stmtResultSet, 0)); /* id,  decimal */
        printf(“%s |”, sqlite3_column_text(stmtResultSet, 1)); /* valor, varchar */
        printf(“%s \n”, sqlite3_column_text(stmtResultSet, 2)); /* traducció, varchar */
        iComptador++;
    }
    printf(“Total de registres: %d\n”, iComptador);
   
    /* tanca el resultset */
    /*
    /* int sqlite3_finalize(sqlite3_stmt *pStmt);
    /* The sqlite3_finalize() function is called to delete a prepared statement.
    /*****/
    sqlite3_finalize(stmtResultSet);
   
    /* tanca la connexió */
    /*
    /* int sqlite3_close(sqlite3 *);
    /* The sqlite3_close() routine is the destructor for the sqlite3 object.
    /*****/
    sqlite3_close(conn);
   
    return (0);
}

Per a poder compilar el codi anterior, és necessari enllaçar-lo amb la llibreria de l’SQLite3. Per a fer això, modifico {nom-projecte}_LDFLAGS = -lsqlite3.
Com a alternativa, també hauria pogut generar un makefile particular.

Inclús en tindríem prou amb una instrucció del tipus:
gcc ./main.c -o prova-csqlite.exe -lsqlite3

Finalment, podem compilar i muntar amb l’Anjuta; i executem:

EXECUTING:
/home/albert/wk-c/prova-c-sqlite/c_sqlite
———————————————-
1 |valor1 |traducció 1
2 |valor2 |traducció 2
3 |valor3 |traducció 3
4 |valor4 |traducció 4
5 |valor5 |nova traducció
Total de registres: 5

———————————————-
Program exited successfully with errcode (0)
Press the Enter key to close this terminal …

Com sempre, diposar de la documentació és clau per a poder reeixir en els desenvolupaments. La documentació està disponible al lloc de SQLite a Internet. D’aquesta altre adreça en podem descarregar un zip amb la documentació.

Una aproximació a Tcl

Fa molt de temps que es fan aplicacions amb interfases gràfiques a Linux. Un dels llenguatges veterans per a la construcció d’interfases gràfiques és el Tcl quan s’acompanya del toolkit gràfic Tk. El Tcl/Tk.

En propietat, el llenguatge és Tcl. Tk és un toolkit, una afegit, una extensió, que permet crear finestres, posar botons, camps de text, llistes… els widgets típics d’una aplicació de finestres fent servir el llenguatge Tcl o altres llenguates.

Entre aquests altres llenguatges que poden fer servir TK hi ha Python. Python proporciona el mòdul TkInter que permet construir interfases gràfiques fent servir widgets de forma similar a com es fa amb Tcl.

Tcl té algunes característiques que el fan molt interessant:
– és interpretat, per tant, fàcil de desenvolupar i distribuir. L’intèrpret de tcl és tclsh; A més, l’interpret per a desenvolupar aplicacions amb Tk: wish
– interacció amb les comandes de la shell: la comanda exec permet executar instruccions de la shell
– tipus de dades únic: cadena de text; estructures de dades de llistes i arrays associatius.
– estructures de control: if-else, foreach,
– procediments
– extensió senzilla del llenguatge amb C. Càrrega dinàmica de llibreries d’extensió amb la comanda load.
– la substitució de cadenes en temps d’execució és la clau per a l’utilització productiva de Tcl. Tenir clar quan utilitzar “”, {}, [], ()… i les diferents substitucions que es produeixen amb unes o altres és la clau de l’èxit.

A continuació, alguns exemples amb tcl. Els poso en un script de la forma habitual a Unix.

#!/usr/bin/tclsh

#analitza els arguments d’entrada i els mostra amb foreach
puts $argv
puts “Número d’arguments: $argc”
foreach arg $argv {
puts “Argument: $arg”
}

# fa càlculs aritmètics
set a 10
set b 25
puts “$a * $b = [expr $a * $b]”

#llistes associatives que simulen arrays
set mat(1) 4
set mat(2) 3
puts “mat(1): $mat(1)”
puts “mat(2): $mat(2)”

# els índexos són cadenes.
set telefon(personal) 123456789
set telefon(movil) 666666666
set telefon(feina) 987654321
puts “telefons disponibles: [array names telefon]”
puts “Mostra tot: [array get telefon]”

# entrada senzilla per teclat
puts “quin vols veure?”
gets stdin nom
# passa a majúscules
puts “Has triat: [string toupper $nom]”
# el mostra
puts “Telefon de $nom: $telefon($nom)”

#treball amb llistes
set progs [list man gedit thunderbird firefox ls cat wc dd dc]
puts “llista: $progs”
puts “llarg de la llista: [llength $progs]”
#index de la llista comença amb 0
puts “element 3: [lindex $progs 3]”
puts “elements 2 a 6: [lrange $progs 2 6]”
puts “afegeix element al final”;
set progs [lappend progs tclsh]
puts “llista: $progs”
puts “afegeix element enmig de la llista”;
set progs [linsert $progs 3 wish]
puts “llista: $progs”


# obrir fitxers per llegir i esciure
#obre un fitxer per a escriure-hi (obté descriptor de fitxer per a escriptura “w”)
set fdw [open prova-tcl.txt w]
puts $fdw “Escriu una línia”
puts $fdw “Escriu una altre línia”
puts $fdw “Escriu la línia del final”
close $fdw

#Llegeix el fitxer (obté descriptor de fitxer per a lectura “r”)
set fdr [open prova-tcl.txt r]
while {![eof $fdr]} {
gets $fdr linea
puts $linea
}
close $fdr

En fi, tot allò que podem esperar d’un llenguatge d’script i potser alguna cosa més.

Hi ha gran quantitat de documentació en línia sobre Tcl.  Vet aquí uns quants enllaços útils:

El manual de referència de Tcl

Tcl developer site
Curs de Tcl a la Universitat de Chicago
Tclers wiki

I també uns manuals en format PDF per a descarregar i tenir-los a ma.

Tcl/Tk quick start
Tcl/Tk reference guide

Per a més endavant, un post sobre Tk.