Business Logic

Lavorare con XML parte 2

Sabrina C. — Mon, 01 Nov 2010 08:28:58 GMT

Che cosa ci viene offerto gratuitamente dal sistema

Come ho già spiegato nel precedente post, .NET è molto XML friendly, pertanto ci offre una serie di funzionalità di base al riguardo senza che dobbiamo divertirci a fare le cose a manina. Pertanto ho costruito una classe fondamentalmente inutile che però ci dimostra come tutti i tipi di dati di base di .NET sono serializzabili.

using System;
using System.Text;

namespace DnwEnitities.Entities
{
    public class Serializzabile
    {

        public Serializzabile()
        {
            TheChar = 'A';
            TheByte = 10;
            TheBool = true;
            TheShort = 100;
            TheInt = 1000;
            TheLong = 1000000;
            TheFloat = 1234.7899f;
            TheDouble = 9800000.89600;
            TheDecimal = 766000000.654390001m;
            TheString = "The string is very nice and useful.";
            TheDate = DateTime.Now;
            TheGuid = Guid.NewGuid();
            TheEnum = SerializableEnum.ALot;
        }
    
        public char TheChar
        {
            get;
            set;
        }

        public byte TheByte
        {
            get;
            set;
        }

        public bool TheBool
        {
            get;
            set;
        }

        public short TheShort
        {
            get;
            set;
        }

        public int TheInt
        {
            get;
            set;
        }

        public long TheLong
        {
            get;
            set;
        }

        public float TheFloat
        {
            get;
            set;
        }

        public double TheDouble
        {
            get;
            set;
        }

        public decimal TheDecimal
        {
            get;
            set;
        }

        public string TheString
        {
            get;
            set;
        }

        public DateTime TheDate
        {
            get;
            set;
        }

        public Guid TheGuid
        {
            get;
            set;
        }

        public SerializableEnum TheEnum
        {
            get;
            set;
        }

        public static Serializzabile ReadXml(string pSerializedData, bool pIsXmlData)
        {
            Serializzabile retP = null;
            if (!pIsXmlData)
            {
                retP = (Serializzabile)SerializeHelper.DeserializeFromFile(
                   typeof(Serializzabile), pSerializedData);
            }
            else
            {
                retP = (Serializzabile)SerializeHelper.DeserializeFromString(
                   typeof(Serializzabile), pSerializedData);
            }
            return (retP);
        }

        public virtual void WriteXml(string pFileName)
        {
            SerializeHelper.SerializeToFile(pFileName, this, typeof(Serializzabile), false, string.Empty);
        }

        public virtual string WriteXml()
        {
            return (SerializeHelper.SerializeToString(this, false, string.Empty));
        }

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("Char: {0}", this.TheChar);
            sb.AppendLine();
            sb.AppendFormat("Byte: {0}", this.TheByte);
            sb.AppendLine();
            sb.AppendFormat("Bool: {0}", this.TheBool);
            sb.AppendLine();
            sb.AppendFormat("Short: {0}", this.TheShort);
            sb.AppendLine();
            sb.AppendFormat("Int: {0}", this.TheInt);
            sb.AppendLine();
            sb.AppendFormat("Long: {0}", this.TheLong);
            sb.AppendLine();
            sb.AppendFormat("Float: {0}", this.TheFloat);
            sb.AppendLine();
            sb.AppendFormat("Double: {0}", this.TheDouble);
            sb.AppendLine();
            sb.AppendFormat("Decimal: {0}", this.TheDecimal);
            sb.AppendLine();
            sb.AppendFormat("String: {0}", this.TheString);
            sb.AppendLine();
            sb.AppendFormat("Date: {0}", this.TheDate);
            sb.AppendLine();
            sb.AppendFormat("Guid: {0}", this.TheGuid);
            sb.AppendLine();
            sb.AppendFormat("Enum: {0}", this.TheEnum);
            sb.AppendLine();
            return (sb.ToString());
        }

    }

    public enum SerializableEnum : int
    {
        None = 0,
        All,
        Some,
        ALot
    }
    
}

Questa classe, rappresenta l’entity più grezza e semplice, contiene una serie di property pubbliche, una per ogni tipo di dato base usato in .NET, contiene i Metodi WriteXml e ReadXml, un override del metodo ToString per permetterci di visualizzarne il contenuto ed infine una enumerazione che ci permette di mostrare che anche i dati enumerati, sono serializzati automaticamente.

Instanziando la classe e lanciando WriteXml su un file, otterremo il seguente risultato:

<?xml version="1.0" encoding="utf-8"?>
<Serializzabile xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance 
     xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <TheChar>65</TheChar>
    <TheByte>10</TheByte>
    <TheBool>true</TheBool>
    <TheShort>100</TheShort>
    <TheInt>1000</TheInt>
    <TheLong>1000000</TheLong>
    <TheFloat>1234.78992</TheFloat>
    <TheDouble>9800000.896</TheDouble>
    <TheDecimal>766000000.654390001</TheDecimal>
    <TheString>The string is very nice and useful.</TheString>
    <TheDate>2010-11-01T09:26:13.331+01:00</TheDate>
    <TheGuid>3da90b04-ec02-4308-a177-fc6723ab8aa9</TheGuid>
    <TheEnum>ALot</TheEnum>
</Serializzabile>

Usando la ReadXml per rileggere il file, otterremo una classe equivalente a quella da noi salvata.

Se non abbiamo particolari esigenze, questo è il metodo più semplice di ottenere un entità serializzabile.

Technorati Tag: XML,entities,serialization

Collection e predicati cercare elementi senza cicli

Sabrina C. — Fri, 13 Aug 2010 15:02:28 GMT

Una delle cose che risultano essere più utili, quando si lavora con le collezioni, sono i metodi di Ricerca, che ci permettono di trovare un elemento della collezione utilizzando come criterio una o più delle sue proprietà. Questi metodi, possono essere creati sia come Indexer, ovvero le property che ci permettono di trovare un elemento passando il valore di una o più proprietà dello stesso, oppure come metodi specifici. Questa seconda opzione, si utilizza perché spesso ci possono essere più property dello stesso tipo che possono essere usate per la ricerca, pertanto non è possibile creare degli indexer per tutte loro. Lavoriamo su un esempio:

La classe Entity, da noi definita che chiameremo AnagraficaAzienda, espone le seguenti proprietà:

string DescrizioneRicerca
string RagioneSociale
string PartitaIva
string Indirizzo
string CAP
string Citta
string PV
int IDTipo
int IDAnagrafica

Per creare un Indexer per cercare dati usando la Descrizione di Ricerca possiamo usare questo codice:

public AnagraficaAzienda this[string pDescrizioneRocerca]
{
    get
    {
        return( Find(item=>item.DescrizioneRicerca==pDescrizioneRicerca);
    }
}

per creare un metodo che ritorna una lista dei dati in cui la ragione sociale soddisfa una regular expression:

public List<AnagraficaAzienda> FindWithRegEx( string pRegEx )
{
    return (FindAll(items => Regex.Match(items.RagioneSociale, pRegEx).Success));
}

per creare un metodo che ritorna una anagrafica con una determinata partita IVA:

public AnagraficaAzienda FindXPartitaIva(string pPartitaIva)
{
    return( Find(item=>item.PartitaIva==pPartitaIva);
}

Per creare un indexer multi dimensionale possiamo usare il seguente codice

public AnagraficaAzienda this[int pIDZona, int pIDAnagrafica]
{
    get
    {
        return( Find(item=>item.IDZona==pIDZona && item.IDAnagrafica==pIDAnagrafica);
    }
}

Come possiamo vedere, un predicato ci permette di indicare una qualsiasi espressione binaria quale criterio di ricerca.

Tags: Collection, Predicate, Find, FindAll

Un interessantissimo articolo per capire i threads

Sabrina C. — Tue, 01 Jun 2010 16:18:58 GMT

Cercando sui motori di ricerca a volte capita di trovare delle cose interessanti anche se non hanno molto a che vedere con quello che stai cercando.

Oggi, cercando alcune notizie sull’intercettazione di un keypress, il mio collega ha trovato questo articolo:

http://www.albahari.com/threading/

scritto da un certo signor Joseph Albahari, che spiega in dettaglio tutto quello che è necessario sapere per lavorare con i threads in una applicazione.

Pertanto lo appunto qui sia per me che per chi legge e faccio i miei complimenti al Signor Albahari per la sua chiarezza.

Tags: Threads, multithreading, C#

Convertire numeri in array di byte

Sabrina C. — Fri, 10 Oct 2008 21:57:27 GMT

Quando lavoravo in C non c'era alcun problema a scrivere su un file binario un intero o un altro valore trasformandolo in un array di byte, bastava una cosa di questo tipo:

char bytes[5] = (char *)myinteger;

Ok, non è proprio preciso ma ci assomiglia :D scusate ma è un po' che non lo uso quindi a memoria non è facile. In .NET invece dove le tipizzazioni e il codice managed rendono a volte le cose complicate, visto che questo tipo di operazione non è quotidiana mi dimentico sempre come si fa, pertanto lo scrivo:

int val = 0x10008000;
byte[] bar = BitConverter.GetBytes(val);
File.WriteAllBytes("test.bin", bar);

Il BitConverter che forse sarebbe stato più simpatico si chiamasse ByteConverter, permette di convertire in un array di Byte vari tipi di dati.

L'utilità, come si può vedere dal codice qui sopra è quella di scrivere su un file binario il contenuto di una variabile. Ricordo che ci sono ovviamente strumenti più moderni e più adatti, la Serializzazione binaria ad esempio ma quando serve una cosa veloce, anche questo può aiutare.

Tags: Classi, Array, Byte