Helper e Generics

Conversioni che passione

Sabrina C. — Fri, 14 Oct 2011 19:35:04 GMT

Ieri ho bloggato una nota per alcune conversioni poco frequenti che ho dovuto fare a causa di una routine di checksum che ho scritto per Alberto. Oggi ho scoperto che la mia ottimistica versione era largamente superata dal meccanismo reale del calcolo del checksum, per riuscire a riprodurre il quale ho dovuto effettuare una serie di stranezze che vi listo di seguito nel caso abbiate la “fortuna” (poca) di scontrarvi con qualcosa di simile.

Leggere un sub-array da un byte array

byte[] sourceArray;
... //Qui mettete i bytes nell’array leggendo un file o una seriale
byte[] destArray = new byte[desiredSublength]
Array.Copy(sourceArray, StartIndex, destArray, DestStartIndex, Length);

Conversione dei bytes nei corrispondenti caratteri ascii

char[] chars = System.Text.Encoding.UTF8.GetChars(destArray);

Far diventare una porzione dell’array di caratteri una string

string subValue = new string(charsArray, startIndex, length);

Convertire la stringa rappresentante un numero esadecimale in un byte

byte myHexByte = Convert.ToByte("1C", 16);

Convertire un byte in una stringa rappresentante il numero in esadecimale

string hexString = Convert.ToString(myByteValue, 16);

Fate attenzione che la stringa sia correttamente upper o lower case

string lowerHex = hexString.ToLower();
string upperHex = hexString.ToUpper();

Questo perché db e DB sono lo stesso numero ma cambiano completamente se convertite la stringa in un char array

char[] hexLetters = upperHex.ToCharArray();

e poi convertite il char array in un byte array

byte[] bytesFromHexLetters = new byte[hexLetters.Length];
for (int i = 0; i < hexLetters.Length; i++)
{
   bytesFromHexLetters [i] = Convert.ToByte(chars[i]);
}

Provate con le lettere esadecimali in upper e lower case e ve ne accorgete, e se mi chiedete, ma tutto in una routine di calcolo del checksum? qui lo chiamiamo Ufficio Complicazione Affari Semplici, sembra essere spesso molto affollato.

Lezioni di “pesca” .Net in C# parte 5

Sabrina C. — Sun, 15 May 2011 09:28:55 GMT

Siamo arrivati alla quinta lezione di C# della serie, abbiamo concluso la gestione della nostra prima classe, la classe persona, pertanto per proseguire e presentare tutti gli aspetti di quello che si può fare con C# iniziamo a pensare a una piccola applicazione, che ci permetterà di spiegare le enumerazioni, le collezioni, l'ereditarietà, la serializzazione XML e probabilmente molte altre cose che verranno.

Avendo come base la classe persona, ho deciso di creare una classe per gestire il curriculum di un programmatore con informazioni anagrafiche, un minimo di informazioni "fiscali", una collezione di competenze che descrivano quello che lui sa fare ed una collezione di lingue conosciute con la loro descrizione. In seguito magari potremo estendere ulteriormente il tutto.

In questo Webcast, oltre a spiegare a grandi linee cosa faremo nelle prossime lezioni, creiamo una Enumerazione e vediamo come si usa, e creiamo la classe base Competence per descrivere le competenze del programmatore, gli aggiungiamo funzionalità e spieghiamo come salvare su disco le informazioni usando XML e spiegando le basi della serializzazione (qualcosa di non nuovo a questo blog, che però in un webcast permette di approfondire i vari concetti di base).

Come sempre buona “pesca” e alla prossima lezione.

Il link al codice sorgente della quinta lezione

Tag di Technorati: C#,class,enum

Il link al webcast se avete problemi a visualizzarlo direttamente è questo: Un po' piu' di hello World - lezione 5

Lavorare con XML parte 1

Sabrina C. — Sun, 31 Oct 2010 22:02:06 GMT

Dopo un mese dall’evento di Pordenone, riesco finalmente ad avere il tempo di iniziare una breve serie di post dedicati alla serializzazione delle entity. Inizierò con l’helper di serializzazione già discusso in passato, ma ora riveduto e corretto usando il framework 4.0.

Per persistere su disco una classe C# (oVB) bisogna che questa classe sia creata con alcuni, semplici accorgimenti che la rendano Serializzabile. Serializzazione è una parola che è iniziata ad arrivare ai miei orecchi attorno al 2003, alle prime conferenze su .NET, è una parola derivata dall’inglese Serialization, non esiste sul Devoto Oli, il suo significato è persistere lo stato di un oggetto che si trova nella memoria di un programma in esecuzione in modo tale da poter rigenerare l’oggetto nello stesso stato rileggendo le informazioni salvate su un disco (o altro analogo supporto di memoria di massa.)

Le classi Entity, sono delle classi che non hanno nulla di particolare se non il fatto che rappresentano dei dati strutturati, pertanto vengono considerate tali tutte le classi che compongono ad esempio un modello dati, semplice, usato con LinqToSql oppure con EntityFramework, pertanto sono quelle che con maggiore probabilità hanno la necessità di essere serializzate.

In .NET, è possibile serializzare dati in 2 modalità, la serializzazione binaria e la serializzazione XML. Tutti i tipi di dati base di .NET sono serializzabili, pertanto, qualsiasi classe che contiene solo dati di questo tipo è serializzabile in modo diretto, senza particolari modifiche se non che è indispensabile che la classe implementi un costruttore senza parametri.

Che cosa viene serializzato automaticamente da .NET di un oggetto? Tutte le property Pubbliche, perché le sole property pubbliche? perché si assume che le variabili private possano essere rigenerate senza necessità di essere serializzate. Ma è ovviamente possibile effettuare un Override della serializzazione automatica e serializzare ciò che si vuole e come si vuole.

In questa serie di articoli esamineremo solo la serializzazione standard e tutto quello che si può pilotare in essa utilizzando poche semplici funzionalità a nostra disposizione.

La classe SerializeHelper

Questa classe fornisce tutti i servizi di serializzazione sia per oggetti semplici che per oggetti compositi (collezioni od oggetti contenenti tipi di dati non semplici). Utilizza le classi del namespace System.Xml e System.Xml.Serialization. Vediamone quindi i vari metodi:

BuildReader

        public static XmlTextReader BuildReader(string pXmlString)
        {
            NameTable nt = new NameTable();
            XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
            nsmgr.AddNamespace("bk", "urn:sample");

            XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None);

            return (new XmlTextReader(pXmlString, XmlNodeType.Element, context));
        }

Questo primo metodo, come dice il suo nome, crea un XmlTextReader, che con il corrispondente XmlTextWriter sono gli stream di base per la lettura e scrittura di dati XML. Il metodo qui scritto, è stato disegnato per permetterci di trasformare una stringa (ad esempio un campo di un database) in uno stream Xml. Si occupa di generare un contesto “fittizio” per così dire, per poter creare l’XmlTextReader in grado di fornire i dati Xml anche se l’input è una semplice stringa, non uno stream dati vero e proprio.

DeserializeFromString

        public static object DeserializeFromString(Type pTypeToDeserialize, string pXmlString)
        {
            object ret = null;
            using (XmlReader xr = BuildReader(pXmlString))
            {
                XmlSerializer serializer = new XmlSerializer(pTypeToDeserialize);
                ret = serializer.Deserialize(xr);
                xr.Close();
            }
            return (ret);
        }

        public static object DeserializeFromString(Type pTypeToDeserialize, 
               Type[] pExtraTypes, string pXmlString)
        {
            object ret = null;
            using (XmlReader xr = BuildReader(pXmlString))
            {
                XmlSerializer serializer = new XmlSerializer(pTypeToDeserialize, pExtraTypes);
                ret = serializer.Deserialize(xr);
                xr.Close();
            }
            return (ret);
        }

Questi due metodi, costruiti l’uno per una classe contenente solo dati semplici, l’altro per una classe contenente tipi di dati complessi, utilizzano il metodo precedente per creare uno stream dati che poi viene passato alla classe XmlSerializer e permette di ottenere l’oggetto originalmente serializzato.

DeserializeFromFile

        public static object DeserializeFromFile(Type pTypeToDeserialize, string pPath)
        {
            object ret = null;
            using (XmlTextReader reader = new XmlTextReader(pPath))
            {
                // Occorre un'istanza della classe XmlSerializer
                XmlSerializer serializer = new XmlSerializer(pTypeToDeserialize);
                // e questo é tutto ciò che serve per leggere i dati dal formato XML
                ret = serializer.Deserialize(reader);
                reader.Close();
            }
            return (ret);
        }

        public static object DeserializeFromFile(Type pTypeToDeserialize, 
            Type[] pExtraTypes, string pPath)
        {
            object ret = null;
            using (XmlTextReader reader = new XmlTextReader(pPath))
            {
                // Occorre un'istanza della classe XmlSerializer
                XmlSerializer serializer = new XmlSerializer(pTypeToDeserialize, pExtraTypes);
                // e questo é tutto ciò che serve per leggere i dati dal formato XML
                ret = serializer.Deserialize(reader);
                reader.Close();
            }
            return (ret);
        }

La deserializzazione da file è più semplice in quanto l’XmlTextreader può essere direttamente istanziato a partire dal nome di un file. I due overload di questo metodo permettono di specificare al deserializzatore quali sono le classi coinvolte, nel caso di oggetti non semplici. Vedremo il loro uso quando deserializzeremo le collection, ma allo stesso modo sono utili per la deserializzazione di oggetti complessi, che formano modelli con relazioni.

SerializeToFile

        public static void SerializeToFile(string pPath, object pObjToSerialize, 
          Type pTypeToSerialize, bool pNoNamespaces, string pPrefix)
        {
            FileInfo fInfo = new FileInfo(pPath);
            if (!Directory.Exists(fInfo.DirectoryName))
            {
                Directory.CreateDirectory(fInfo.DirectoryName);
            }            
            using(XmlTextWriter writer = new XmlTextWriter(pPath, Encoding.UTF8))
            {
                // write a readable file
                writer.Formatting = Formatting.Indented;
                writer.Indentation = 4;

                // Occorre un'istanza della classe XmlSerializer
                XmlSerializer serializer = new XmlSerializer(pTypeToSerialize);
                XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
                string prefix = pPrefix != null ? pPrefix : string.Empty;
                if (pNoNamespaces)
                {
                    ns.Add(prefix, TXT_Namespace);
                }
                // e questo é tutto ciò che serve per persistere i dati
                serializer.Serialize(writer, pObjToSerialize, ns);
                writer.Close();
            }
        }

        public static void SerializeToFile(string pPath, object pObjToSerialize, 
            Type pTypeToSerialize, Type[] pExtraTypes, bool pNoNamespaces, string pPrefix)
        {
            FileInfo fInfo = new FileInfo(pPath);
            if (!Directory.Exists(fInfo.DirectoryName))
            {
                Directory.CreateDirectory(fInfo.DirectoryName);
            }            
            using(XmlTextWriter writer = new XmlTextWriter(pPath, Encoding.UTF8))
            {
                // write a readable file
                writer.Formatting = Formatting.Indented;
                writer.Indentation = 4;
                //writer.Settings.OutputMethod = XmlOutputMethod.
                // Occorre un'istanza della classe XmlSerializer
                XmlSerializer serializer = new XmlSerializer(pTypeToSerialize, pExtraTypes);
                XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
                string prefix = pPrefix != null ? pPrefix : string.Empty;
                if (pNoNamespaces)
                {
                    ns.Add(prefix, TXT_Namespace);
                }
                // e questo é tutto ciò che serve per persistere i dati
                serializer.Serialize(writer, pObjToSerialize, ns);
                writer.Close();
            }
        }

Per la serializzazione, oltre ai due overload che ci danno modo di dare informazioni al serializzatore sulle classi coinvolte, abbiamo aggiunto alcuni parametri che servono per la formattazione: pNoNamespaces e pPrefix.
Innanzi tutto possiamo notare come Creando l’XmlTextWriter, la classe che effettua la serializzazione, possiamo decidere l’encoding della stringa, pertanto, in base alle nostre esigenze possiamo cambiare l’encoding del file generato. Possiamo inoltre controllare la formattazione del file Xml generato usando l’opzione Formatting che ci da modo di indicare come deve essere formattato il testo, alcune altre property permettono di decidere l’ampiezza dell’indentazione e il carattere da utilizzare.

l’uso di XmlSerializerNamespaces ci permette di evitare la verbosa serie dei namespaces inseriti all’apertura della serializzazione della classe:

Sostituendola con:

Oppure, usando il flag pNoNamespaces in:

Questo flag è opportuno utilizzarlo per creare classi neutre da utilizzare per lo scambio dati fra applicazioni di aziende diverse, mentre se vogliamo fare in modo che le nostre classi siano marcate in modo specifico, lasciamo invece il namespace che abbiamo scelto per la nostra azienda, in modo tale che sia necessario specificamente implementarlo nelle classi da noi prodotte in modo tale da renderle univoche rispetto a quelle prodotte da altri.

Il parametro pPrefix ha invece lo scopo di assegnare un prefisso agli elementi delle nostre classi.

<dnw:Programmer xmlns:dnw="http://www.dotnetwork.it">

<dnw:Skills>

In questo modo possiamo specificare esattamente l’uso dei nostri oggetti senza dover reinserire il namespace completo.

SerializeToString

        public static string SerializeToString(object pObjToSerialize, 
            Type[] pExtraTypes, bool pNoNamespaces, string pPrefix)
        {
            string ret = string.Empty;
            using (MemoryStream stream = new MemoryStream())
            {
                XmlSerializer serializer = new XmlSerializer(pObjToSerialize.GetType(), pExtraTypes);
                XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
                string prefix = pPrefix != null ? pPrefix : string.Empty;
                if (pNoNamespaces)
                {
                    ns.Add(prefix, TXT_Namespace);
                }
                serializer.Serialize(stream, pObjToSerialize, ns);
                ret = Encoding.UTF8.GetString(stream.ToArray());
                stream.Close();
            }
            return (ret);
        }

        public static string SerializeToString(object pObjToSerialize, bool pNoNamespaces, string pPrefix)
        {
            string ret = string.Empty;
            using (MemoryStream stream = new MemoryStream())
            {
                XmlSerializer serializer = new XmlSerializer(pObjToSerialize.GetType());
                XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
                string prefix = pPrefix != null ? pPrefix : string.Empty;
                if (pNoNamespaces)
                {
                    ns.Add(prefix, TXT_Namespace);
                }
                serializer.Serialize(stream, pObjToSerialize, ns);
                ret = Encoding.UTF8.GetString(stream.ToArray());
                stream.Close();
            }
            return (ret);
        }

L’ultimo metodo, sempre con due overload, permette la serializzazione di un oggetto in Xml su una stringa, per poterlo fare dobbiamo utilizzare uno Stream, visto che dobbiamo poi trasformarlo in una stringa, utilizziamo un Memory Stream, per non dover generare un file. La procedura per la generazione dell’Xml, è identica a quella per i files.

Technorati Tag: C#,Xml,Serializzazione,Helper

This assembly is built by a runtime newer than the currently loaded runtime and cannot be loaded.

Sabrina C. — Fri, 18 Jun 2010 12:56:24 GMT

Scusate lo strano titolo del post, ma probabilmente chi incontrerà questo errore proverà a cercarlo su un motore di ricerca e me ne sarà grato.

Premessa: I miei programmi, quando installati sui PC degli utenti finali per principio Non usano la GAC a meno che io non vi sia obbligata per poter esporre una qualche funzionalità a .COM.

Però, per la struttura con cui sono costruite le molte ed articolate librerie di base utilizzate per i miei progetti, tali librerie di base sulle macchine di sviluppo (e solo sulle macchine di sviluppo) vengono pubblicate in GAC. Questo serve a permettere a noi programmatori di poter aggiornare una libreria di base ed essere certi che qualsiasi soluzione/progetto che usa questa libreria base istantaneamente abbia le modifiche disponibili.

Per quale motivo facciamo tutto questo, perché le DLL poste in GAC non vengono copiate sulla cartella locale di ogni progetto che le usa da Visual Studio e quindi, ricompilando il progetto che referenzia la DLL base, esso fa certamente riferimento alla DLL giusta.

Questa soluzione è stata adottata dopo che il setup di una applicazione, a causa dell’ordine in cui il progetto di setup ha copiato le DLL referenziate quando è stato generato, ha inserito una versione vecchia di una dll e quindi l’aggiornamento installato dal cliente non funzionava.

Detto questo, che roba è il titolo di questo post?

Il titolo di questo post è il messaggio di errore che gacutil.exe, l’utility che installa e disinstalla dalla GAC gli assembly produce tentando di caricare in GAC una DLL compilata con il framework 4.0. Il gacutil.exe che uso io, me lo porto dietro dal 2005, infatti tale utility si trova sperduta nei meandri dell’SDK di Windows quindi, opportunamente, io ne ho fatto copia e la metto su C:\Windows così sono sicura di trovarla (Lo so che per qualche sistemista sarà un eresia, ma ragazzi, noi programmatori dobbiamo lavorà!)

Detto ciò, la mia utility scritta per il framework 2.0 funziona correttamente fino al framework 3.5 poi non funziona più e da questo messaggio.

Il motivo per cui non funziona più non lo so esattamente ma, con il framework 4.0 la GAC non si trova più dove era prima, ovvero:

c:\Windows\Assembly

ma è stata spostata (per ragioni più che giustificate ovviamente) e si trova sotto:

C:\Windows\Microsoft.NET\assembly\GAC_MSIL (per lo meno sul mio pc con windows Vista business)

pertanto, è necessario procurarsi ed usare il nuovo gacutil.exe fornito con Visual Studio 2010 accessibile senza tema usando il prompt dei comandi di Visual Studio, ma nascosto e praticamente introvabile a chi non conosca per filo e per segno le cartelle degli SDK di Microsoft.

Sulla mia macchina, il nuovo gacutil.exe si trova qui:

C:\Program Files\Microsoft SDKs\Windows\v7.0A\bin\NETFX 4.0 Tools

Sostituito questo con l’originale la registrazione va a buon fine e gli assembly vengono copiati sulla GAC correttamente, e ovviamente vengono correttamente registrati anche gli assembly delle versioni precedenti del framework.

Tags: GAC, gacutil, VS2010

Disattivare il caricamento automatico dei Controlli in Toolbox

Sabrina C. — Mon, 30 Mar 2009 08:22:31 GMT

Se come me avete delle soluzioni che creano un certo numero di Components (da 30 a 200), la funzionalità per cui Visual Studio aggiunge automaticamente questi Tools alla Toolbox ad ogni ricompilazione, apertura della soluzione, modifica o aggiunta di una nuova classe, può risultare noiosa, prima di tutto perché durante questa operazione non ci sono cursori di attesa e sembra che Visual Studio sia Piantato, secondariamente perché difficilmente andrete a trascinare componenti in una soluzione di soli componenti se non per fare dei test, ma in questo caso credo siate sufficientemente cresciuti da poter scrivere una riga di codice a mano per creare il componente. Per togliere il fastidio basta eseguire la seguente modifica alle opzioni di Visual Studio: Tools > Options > Windows Forms Designer > ToolBox > AutoToolboxPopulate = false Al contrario, se per qualsiasi motivo questa funzione non vi venisse eseguita automaticamente e a voi serve, controllate che questo flag sia posto a True. Ricordo che le classi prese in considerazione da questa funzione sono quelle derivate da Control e Component.

Tags: VisualStudio Toolbox

SQL Server Come impostare una Query che ritorna sempre almeno una riga.

Sabrina C. — Sat, 12 Apr 2008 14:07:49 GMT

Faccio un Post per interposta persona, infatti questa soluzione arriva dal mio nuovo collega, Luca Del Mestre che spero di convincere presto a scrivere personalmente su DotNetWork.

Scenario:

Spesso ci troviamo ad avere la necessità di leggere da Database un singolo record di una tabella, a volte contiene dei parametri da usare nell'applicazione, a volte contiene il dettaglio di un particolare dato, è comunque comune alle applicazioni che lavorano con i DB.

Se la query che ci aspettiamo ritornare una riga non torna nulla, spesso, il codice necessario a gestire questo tipo di accadimento è lungo e decisamente poco utile, farebbe invece comodo e ci permetterebbe di risparmiare parecchio codice e parecchi grattacapi se la query ritornasse una riga in ogni caso, solamente facendo in modo che una riga non valida sia vuota.

Luca, che è un DBA Oracle, mi ha mostrato come in Oracle vi sia una sintassi nel dialetto SQL che permette di ottenere questo tipo di funzionalità, SQL Server ne ha una corrispondente però, in SQL 2005 applicandola si riceve un messaggio di errore che la indica come parte di SQL 2000 da non usarsi se non modificando il livello di compatibilità del db alla versione 2000. Ma ovviamente c'è sempre un metodo alternativo per risolvere il problema.

L'esempio che vi posto è creato su una ipotetica tabella Users che mappa gli utenti Windows che hanno accesso ad una applicazione su database.

La tabella:

USE [paperinik]
GO

CREATE TABLE [dbo].[TbUsers](
    [IDUser] [uniqueidentifier] NOT NULL,
    [WinUser] [nvarchar](128) NOT NULL,
    [WinDomain] [nvarchar](128) NOT NULL,
    [UserName] [nvarchar](255) NOT NULL,
    [DataLogin] [datetime] NULL,
    [IDAzienda] [nchar](3) NULL,
    [InternalMail] [nvarchar](128) NULL,
    [Obsoleto] [bit] NULL,
    [ObsoletoDal] [datetime] NULL,
    [IsAdmin] [bit] NULL,
    [IsSupervisor] [bit] NULL,
    [DirectConnection] [bit] NULL,
    [LastUpdated] [timestamp] NULL,
         CONSTRAINT [PK_TbMcpUsers] PRIMARY KEY NONCLUSTERED 
        (
            [IDMcpUser] ASC
        ) ON [PRIMARY]
    ) ON [PRIMARY]

La classe di test:

    public static class User
    {

        private const string SQL_CnString = "integrated security = SSPI; data source = .; initial catalog = paperinik;";
        public const string FLD_IDUser = "IDUser";
        public const string FLD_WinUser = "WinUser";
        public const string FLD_WinDomain = "WinDomain";
        public const string FLD_UserName = "UserName";
        public const string FLD_IsAdmin = "IsAdmin";

        private const string SQL_ValidateUser = @"
            SELECT [IDUser]
                  ,[WinUser]
                  ,[WinDomain]
                  ,[UserName]
                  ,[DataLogin]
                  ,[IDAzienda]
                  ,[InternalMail]
                  ,[Obsoleto]
                  ,[ObsoletoDal]
                  ,[IsAdmin]
                  ,[IsSupervisor]
                  ,[DirectConnection]
                  ,[LastUpdated]
                FROM TbUsers usr
                RIGHT OUTER JOIN (SELECT @WinUser ut, @WinDomain do) fake
                        ON (usr.WinUser = fake.ut AND usr.WinDomain = fake.do)
        ";
        private const string TXT_UtenteNonValido = "Utente non valido";

        private static readonly string mClassName = System.Reflection.MethodBase.GetCurrentMethod().ReflectedType.Name;

        private static DataRow mUserRow;

        public static Guid IDUser
        {
            get
            {
                if (mUserRow[FLD_IDUser] == System.DBNull.Value)
                {
                    return Guid.Empty;
                }
                else
                {
                    return (Guid)mUserRow[FLD_IDUser];
                }
            }
        }

        public static string WinUser
        {
            get
            {
                if (mUserRow[FLD_WinUser] == System.DBNull.Value)
                {
                    return null;
                }
                else
                {
                    return (string)mUserRow[FLD_WinUser];
                }
            }
        }

        public static string WinDomain
        {
            get
            {
                if (mUserRow[FLD_WinDomain] == System.DBNull.Value)
                {
                    return null;
                }
                else
                {
                    return (string)mUserRow[FLD_WinDomain];
                }
            }
        }

        public static string UserName
        {
            get
            {
                if (mUserRow[FLD_UserName] == System.DBNull.Value)
                {
                    return TXT_UtenteNonValido;
                }
                else
                {
                    return (string)mUserRow[FLD_UserName];
                }
            }
        }

        public static bool IsAdmin
        {
            get
            {
                if (mUserRow[FLD_IsAdmin] == System.DBNull.Value)
                {
                    return false;
                }
                else
                {
                    return (bool)mUserRow[FLD_IsAdmin];
                }
            }
        }


        public static bool IsValid()
        {
            return( UserName != null && UserName != TXT_UtenteNonValido);
        }


        public static void ValidateUser(string pWinUser, string pWinDomain)
        {
            using (SqlConnection cn = new SqlConnection())
            {
                SqlParameter[] sqlParam = new SqlParameter[] {
                    new SqlParameter( "@WinUser", pWinUser ),
                    new SqlParameter( "@WinDomain", pWinDomain )
                };
                cn.ConnectionString = SQL_CnString;
                cn.Open();
                SqlCommand cmd = new SqlCommand();
                cmd.Connection = cn;
                cmd.CommandText = SQL_ValidateUser;
                cmd.Parameters.AddRange(sqlParam);
                SqlDataReader dr = cmd.ExecuteReader();
                if (dr.HasRows)
                {
                    DataTable dt = new DataTable();
                    dt.Load(dr);
                    mUserRow = dt.Rows[0];
                }
                cn.Close();
            }
        }

    }

Che cosa otteniamo provando ad usare la classe in una applicazione Windows dove io ho inserito un record per il signor M.Rossi e invece non ho inserito il signor G.Rossi?:

Il signor G.Rossi non è un utente mappato.

Il signor M.Rossi invece è mappato sulla tabella.

Dov'è il trucco per far si che la query che potete notare all'inizio della classe di test ritorni sempre un record:

            SELECT [IDUser]
                  ,[WinUser]
                  ,[WinDomain]
                  ,[UserName]
                  ,[DataLogin]
                  ,[IDAzienda]
                  ,[InternalMail]
                  ,[Obsoleto]
                  ,[ObsoletoDal]
                  ,[IsAdmin]
                  ,[IsSupervisor]
                  ,[DirectConnection]
                  ,[LastUpdated]
                FROM TbUsers usr
                RIGHT OUTER JOIN (SELECT @WinUser ut, @WinDomain do) fake
                        ON (usr.WinUser = fake.ut AND usr.WinDomain = fake.do)

Il segreto è la RIGHT OUTER JOIN utilizzata per costruire un filtro furbo, ove invece di fare una semplice

WHERE
    WinUser = @WinUser AND WinDomain = @WinDomain

Usiamo i 2 parametri del filtro per costruire una tabella al volo che chiamiamo fake (falsa)

(SELECT @WinUser ut, @WinDomain do) fake

E facciamo una RIGHT JOIN fra questa tabella e la tabella utenti utilizzando la clausola OUTER per cui per ogni riga della tabella posta a destra della JOIN viene creata una riga nella tabella risultante, che, quando non vi fossero valori nella tabella LEFT (la nostra USER) riempie i campi con NULL.

In questo modo, otteniamo un record valido per M.Rossi e un record vuoto per G.Rossi. Come possiamo notare, la nostra classe di test mappa direttamente i campi della DataRow sulle property con la sola gestione del DBNull, senza questa soluzione, per ottenere una classe funzionante, avremmo dovuto mappare i campi su variabili a livello di classe e fare una funzione di Clear che le svuota quando non c'è una riga che possa aggiornare i dati. Avremmo inoltre dovuto aggiornare le variabili a livello di classe dalla DataRow aggiungendo codice ulteriore e OverHead al nostro sistema.

Tags: SQL, Query, CheckIdent,SqlServer

Due parole su GetHashCode e sugli operatori di Uguaglianza (Storico)

Sabrina C. — Mon, 24 Mar 2008 20:43:22 GMT

A che cosa serve GetHashCode?

Domanda che mi è sovvenuta perché dovendo predisporre per una serie di classi un Override dell'operatore == in modo da poterle comparare semplicemente, il sistema mi obbliga (per poter compilare) a fare l'override anche di due metodi della classe che sono:

Equals()

GetHashCode()

Se il primo è, almeno dal nome, semplice da capire il secondo no, pertanto sono andata a cercare di cosa si tratta e come è opportuno farne l'override per mantenerlo corretto. Questa è la traduzione della risposta che ho trovato più coerente:

A cosa serve GetHashCode?

Viene utilizzato per determinare se due oggetti sono identici. Viene utilizzato da Equals nella sua forma standard per determinare se due oggetti sono lo stesso oggetto. Questo è vero se tutti gli attributi della classe sono uguali.

Se si vuole creade le tue strutture o classi e compararle utilizzando Equals, devi costruire il tuo valore di Hash. Il modo più semplice per farlo è fare un or esclusivo tra i valori di Hash degli attributi che identificano il tuo oggetto e ritornare quel valore. Se si effettua l'Override di Equals è necessario fare l'override di GetHashCode().

Operatori di Uguaglianza, e disuguaglianza

Faccio seguito al post precedente, perché mi sono spinta un po' più a fondo sull'argomento e seguendo alcune indicazioni fornite dalle specifiche di base di .NET e dalle best practices che chi ne sa più di me ha fornito sono arrivata a qualcosa di un po' più articolato, ovvero, se volete generare una classe di tipo Entity (che rappresenta quindi un Dato di qualche genere) e volete che questo oggetto supporti la possibilità di essere inserito in una collection, di essere ricercato, ordinato, comparato in modo standard, è necessario procedere nel seguente modo:

Implementare il vostro oggetto in forma base, quindi definirne i campi, le proprietà e la funzione base ToString (perché quella dell'object è un po' misera).
Se volete rendere l'oggetto serializzabile, quindi usabile via WebServices oppure semplicemente scrivibile/leggibile su disco, generare le funzioni ReadXml e WriteXml
Implementare l'interfaccia IComparable, che si compone di un'unico metodo CompareTo che ci permette di stabilire un metodo univoco per definire se due dei nostri oggetti sono uguali, maggiori, minori l'uno all'altro.
Implementare l'operatore di Uguaglianza (==) e obbligatoriamente quello di disuguaglianza (!=) e di conseguenza su richiesta del compilatore implementare l'override dei metodi Equals e GetHashCode.

Una cosa a cui fare molta attenzione è la seguente, le specifiche base di .NET dicono che la funzione Equals deve ritornare true solo se 2 oggetti sono lo stesso oggetto, mentre l'operatore di uguaglianza (==)può coincidere con Equals oppure fornire una uguaglianza in base ai contenuti. E qui, voi, come me direte "Omioddio ma come è possibile..." è molto semplice, anche se un pochino contorto, facciamo un esempio:

DateTime DataUno = new DateTime( 2006, 05, 21);
DateTime DataDue = new DateTime( 2006, 05, 21);

bool  compareValue = DataUno == DataDue;

bool equalValue = DataUno.Equals(DataDue);

In questo caso, compareValue è true, mentre equalValue è false

DateTime DataUno = new DateTime( 2006, 05, 21);
DateTime DataDue = DataUno

bool  compareValue = DataUno == DataDue;

bool equalValue = DataUno.Equals(DataDue);

In questo caso, invece, entrambi i valori di comparazione sono true.

C'è un solo piccolo problema che ogni tanto sono certa ha introdotto bacherozzi in più di una applicazione, se utilizzo la seconda versione, dato che DataUno e DataDue sono lo stesso oggetto, se cambio il contenuto di DataUno ho cambiato di conseguenza anche DataDue, mentre se utilizzo la prima versione, se cambio DataUno, DataDue rimane quella di prima.

A cosa è dovuto tutto questo? Al fatto che mentre Equals si basa sull'uguaglianza fra gli HashCode degli oggetti, == si basa sulla comparazione dei contenuti. Faccio un esempio pratico così vediamo come realizzare una classe Entity che rispetti le specifiche, cioè si comporti come la nostra classe del Framework standard DateTime.

La classe esempio è naturalmente una classe inutile per il 99% di coloro che leggeranno l'articolo, infatti costruisce un Entity che permette di definire una coppia di colori Console per cambiare colore al testo di una Write o Writeline su una finestra console. Però questa classe è serializzabile, comparabile e sortabile secondo direttive standard.

Per permettere un copia incolla utile in visual studio, ve la scrivo tutta, ma commenterò i pezzi che ci interessano scrivendo in Rosso

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml.Serialization;
using ForYou.Base;
using ForYou.Base.Xml;
using System.ComponentModel;
using ForYou.Base.Exceptions;

#endregion

namespace ForYou.UI.TheConsole.Data.Entities
{
    ///
    /// Descrizione della classe: 
    ///
    ///
    ///
    [Serializable, XmlRoot(Namespace = http://www.visual-basic.it)] 
	//Attributo che indica che la classe è serializzabile e il 
		namespace univoco per le nostre Entity
    public class ConsoleItemColor : INotifyPropertyChanged, IComparable
    {
        #region Variabili private

        ///
        /// Nome della classe usato per debug nella generazione delle eccezioni
        ///
        ///
        ///
        private readonly string mClassName = 
	System.Reflection.MethodBase.GetCurrentMethod().ReflectedType.Name;
        private readonly static string mClassNameS = 
	System.Reflection.MethodBase.GetCurrentMethod().ReflectedType.Name;

        ///
        /// Colore del testo
        ///
        ///
        ///
        private ConsoleColor mTextColor;

        ///
        /// Colore dello schermo
        ///
        ///
        ///
        private ConsoleColor mScreenColor;
        #endregion

        #region Events

        ///
        /// Evento che si scatena alla modifica di una delle proprietà
        ///
        ///
        ///
        public event PropertyChangedEventHandler PropertyChanged;
        #endregion

        #region Costruttore

        /// 
        /// Costruttore
        /// 
        /// Colore del testo
        /// Colore dello schermo
        /// 
        /// 
        public ConsoleItemColor( ConsoleColor pTextColor,
	 ConsoleColor pScreenColor)
        {
            this.mTextColor = pTextColor;
            this.mScreenColor = pScreenColor;
        }

        ///
        /// Costruttore
        ///
        ///
        /// V.1.0
        ///
        private ConsoleItemColor()
        {
            this.mScreenColor = ConsoleColor.Black;
            this.mTextColor = ConsoleColor.White;
        }

Una piccola nota sul costruttore privato: questo oggetto deve per forza avere i 2 valori dei colori definiti nel costruttore, però, per essere serializzabile, un oggetto deve implementare un costruttore senza parametri, per evitare che chi usa l'oggetto abbia accesso al costruttore senza parametri, mentre la funzione di Serializzazione e Deserializzazione invece possano utilizzarlo, lo definiamo private.

        #endregion

        #region Proprietà

        /// 
        /// Colore del testo
        /// 
        ///
        ///
        public ConsoleColor TextColor
        {
            get
            {
                return mTextColor;
            }
            set
            {
                mTextColor = value;
                OnPropertyChanged(new PropertyChangedEventArgs("TextColor"));
            }
        }

Una nota sull'implementazione di INotifyPropertyChange: è un interfaccia molto utile ed interessante da implementare sugli oggetti Entity per permettere di reagire alla modifica di una property in modo automatico implementando un Event Handler sull'evento Property Changed (ad esempio sulla User interface - ovviamente la console non è il massimo, però...).

        /// 
        /// Colore dello schermo
        /// 
        ///
        ///
        public ConsoleColor ScreenColor
        {
            get
            {
                return mScreenColor;
            }
            set
            {
                mScreenColor = value;
                OnPropertyChanged(new PropertyChangedEventArgs("ScreenColor"));
            }
        }

        /// 
        /// Restituisce il console Item Color corrente con i colori invertiti
        /// 
        ///
        ///
        public ConsoleItemColor ReverseColor
        {
            get
            {
                return new ConsoleItemColor( this.mScreenColor,this.mTextColor);
            }
        }

        #endregion

        #region Metodi pubblici

        /// 
        /// Operatore di uguaglianza, 2 ConsoleItemColor sono 
		uguali se hanno gli stessi colori per testo e Schermo
        /// 
        /// ConsoleSize da confrontare
        /// ConsoleSize di confronto
        /// 
        /// 
        /// 
        public static bool operator ==(ConsoleItemColor pX, ConsoleItemColor pY)
        {
            try
            {
                bool ret = false;

                object oX = (object)pX;
                object oY = (object)pY;
                if (oX == null && oY == null)
                {
                    ret = true;
                }
                else
                {
                    if (oX != null && oY != null)
                    {
                        if (pX.CompareTo(pY) == 0)
                        {
                            ret = true;
                        } // if
                    }
                }
                return (ret);
            }
            catch (Exception ex)
            {
                throw new ApplicationException(" " + mClassNameS + "."
                    + System.Reflection.MethodBase.GetCurrentMethod().Name + ": " + ex.Message, ex);
            }
        }

Primo dei metodi per noi interessanti: Implementazione dell'operatore di uguaglianza (==) in questo caso, utilizziamo Object come mezzo per testare e gestire correttamente la comparazione con il null quindi trasformiamo gli operandi in Object per poter usare l'operatore di uguaglianza di base. Se non facessimo così, creeremmo una funzione ricorsiva, (provare per credere) e un bellissimo Stack Overflow.
Se gli operandi non sono nulli, l'uguaglianza esiste solo se la funzione CompareTo implementazione di IComparable ritorna 0. Per il CompareTo, scendete un po' più in basso.

        /// 
        /// Operatore di disuguaglianza, 2 
		ConsoleItemColor sono diversi se non sono uguali
        /// 
        /// ConsoleSize da confrontare
        /// ConsoleSize di confronto
        /// 
        /// 
        /// 
        public static bool operator !=(ConsoleItemColor pX, ConsoleItemColor pY)
        {
            try
            {
                return (!(pX == pY));
            }
            catch (Exception ex)
            {
                throw new ApplicationException(" " + mClassNameS + "."
                    + System.Reflection.MethodBase.GetCurrentMethod().Name, ex);
            }

        }

Come possiamo notare, la disuguaglianza è solo una negazione dell'uguaglianza, pertanto la sua descrizione è corretta, due ConsoleItemColor sono diversi se non sono uguali... :o)

        /// 
        /// Indica se 2 instanze di oggetti sono uguali
        /// 
        /// Oggetto da comparare
        /// 
        /// true se obj e this sono lo stesso oggetto e hanno lo stesso valore
        /// false al contrario.
        /// 
        public override bool Equals(object obj)
        {
            bool ret = false;
            try
            {
                if( obj == null )
                {
                    ret = false;
                }
                else
                {
                    if (obj is ConsoleItemColor)
                    {
                        ret = this.GetHashCode() == obj.GetHashCode();
                    } // if
                } // else
            }
            catch (Exception ex)
            {
                if( ExceptionHelper.BaseExceptionTypeEquals(ex,
		 typeof(NullReferenceException) ))
                {
                    if( obj == null )
                    {
                        ret = true;
                    }
                }
                else
                {
                    throw new ApplicationException(" " + mClassName + "." 
                    + System.Reflection.MethodBase.GetCurrentMethod().Name, ex);    
                }
            }
            return( ret );
        }

Anche l'implementazione di Equals è un po' più lunga di una semplice uguaglianza tra HashCode, questo per riuscire a gestire correttamente gli oggetti null, ovviamente se non volete gestire la nullabilità togliete tutto quello che ho scritto e lasciate che Equals lanci una bella NullReferenceException gestendone il risultato a monte.

        /// 
        /// Restituisce lo hash code dell'instanza dell'oggetto
        /// 
        /// 
        /// Un intero a 32-bit che contiene l'hash code dell'instanza dell'oggetto
        /// 
        public override int GetHashCode()
        {
            try
            {
                return(base.GetHashCode());
            }
            catch (Exception ex)
            {
                throw new ApplicationException(" " + mClassName + "."
                    + System.Reflection.MethodBase.GetCurrentMethod().Name, ex);
            }
        }

Contrariamente a quanto indicato nel post precedente, che è una delle modalità per gestire gli Hash, ho scelto di implementare semplicemente la chiamata allo Hash della classe base (Object) perché in questo modo sono certa che Equals funziona come voglio io, ovvero ritorna True solo se gli oggetti comparati sono lo stesso oggetto.

        ///
        /// Visualizza il contenuto della classe come una stringa
        ///
        ///
        ///
        public override string ToString()
        {
            try
            {
                StringBuilder sb = new StringBuilder();
                sb.AppendFormat("{0};{1}", this.TextColor, this.ScreenColor);
                return(sb.ToString());
            }
            catch (Exception ex)
            {
                throw new ApplicationException(" " + mClassName + "."
                    + System.Reflection.MethodBase.GetCurrentMethod().Name + ": " + ex.Message, ex);
            }
        }

        ///
        /// Serializza la classe su un file in formato XML
        ///
        ///Path del file da generare
        ///
        public void WriteXml(string pXmlPath)
        {
            try
            {
                Stat.CheckEmptyPath(pXmlPath);
                ObjSerializer so = new ObjSerializer();
                so.SerializeToFile(pXmlPath, this, typeof(ConsoleItemColor));
            }
            catch (Exception ex)
            {
                throw new ApplicationException(" " + this.mClassName + "."
                    + System.Reflection.MethodBase.GetCurrentMethod().Name + " " + ex.Message, ex);
            }
        }

        /// 
        /// Serializza la classe su una stringa
        /// 
        /// Stringa XML contenente l'oggetto serializzato
        /// 
        public string WriteXml()
        {
            try
            {
                ObjSerializer so = new ObjSerializer();
                return (so.SerializeToString(this));
            }
            catch (Exception ex)
            {
                throw new ApplicationException(" " + this.mClassName + "."
                    + System.Reflection.MethodBase.GetCurrentMethod().Name + " " + ex.Message, ex);
            }
        }

        /// 
        /// Deserializza una classe da un file XML
        /// 
        /// Dati Base x la deserializzazione
        /// if set to true [pXML è un oggetto serializzato] se false è un path.
        /// Ritorna: Un oggetto di tipo MenuItem
        /// 
        /// 
        public static ConsoleItemColor ReadXml(string pXml, bool pIsXmlData)
        {
            ConsoleItemColor ret = null;
            try
            {
                ObjSerializer so = new ObjSerializer();
                if (!pIsXmlData)
                {
                    Stat.CheckEmptyPath(pXml);
                    Stat.CheckNoFile(pXml);
                    ret = (ConsoleItemColor)so.DeserializeFromFile(
			typeof(ConsoleItemColor), pXml);
                } // if
                else
                {
                    ret = (ConsoleItemColor)so.DeserializeFromString(
			typeof(ConsoleItemColor), pXml);
                }
            }
            catch (Exception ex)
            {
                throw new ApplicationException(" " + mClassNameS + "."
                    + System.Reflection.MethodBase.GetCurrentMethod().Name + " " + ex.Message, ex);
            }
            return (ret);
        }

        #endregion

        #region INotifyPropertyChanged Implementazione event handler

        ///
        /// Evento che viene generato 
        ///
        /// Argomenti relativi all'evento
        ///
        ///
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            if (PropertyChanged != null)
                PropertyChanged(this, e);
        }

        #endregion

        #region IComparable Members

        ///
        /// Compara 2 item color
        ///
        ///
        ///
        public int CompareTo(object obj)
        {
            int ret = -1;
            try
            {
                if (obj is ConsoleItemColor)
                {
                    ConsoleItemColor val = (ConsoleItemColor)obj;
                    int textCompare = this.TextColor.CompareTo(val.TextColor);
                    int screenCompare = this.ScreenColor.CompareTo(val.ScreenColor);
                    if (textCompare != 0)
                    {
                        ret = textCompare;
                    }
                    else
                    {
                        ret = screenCompare;
                    }
                }
            }
            catch (Exception ex)
            {
                throw new ApplicationException(" " + mClassName + "."
                    + System.Reflection.MethodBase.GetCurrentMethod().Name, ex);
            }
            return (ret);
        }

E qui abbiamo la nostra ultima fatica, ovvero l'implementazione di CompareTo, per comparare 2 oggetti e definirli uguali, siamo noi a decidere come procedere, in questo caso, due oggetti di tipo ConsoleItemColor sono uguali se hanno lo stesso colore per il testo e lo stesso colore per lo schermo. Inoltre abbiamo stabilito che un ConsoleItemColor è Maggiore di un'altro se ha il colore del Testo maggiore di quello dell'item con cui è comparato, quando i colori del testo fossero uguali, allora il colore dello schermo maggiore ci indica chi è il maggiore dei due. Come stabilire se un colore è maggiore o minore? I ConsoleColor sono una enumerazione intera che va da 0 a 15 pertanto stabiliamo la loro dimensione cercandone il valore numerico.

        #endregion
    }
}

Conclusione: Questo è ovviamente solo un modo per implementare gli operatori di Uguaglianza e di Precedenza su un oggetto di tipo Entity, ciascuno può scegliere di implementarli come preferisce, è necessario però prestare attenzione a come si scrivono questi metodi affinché l'oggetto si comporti poi come vogliamo noi all'interno di un programma.

Tags: GetHashCode, Classi

Come pubblicare assembly in GAC sfruttando i Post Build Events di Visual Studio(Storico)

Sabrina C. — Mon, 24 Mar 2008 20:18:19 GMT

Nelle installazioni delle mie applicazioni sui computer dei miei clienti, non utilizzo mai la GAC per le mie librerie, questo perché non sono abbastanza brava da garantire la Compatibilità fra le DLL che compilo oggi e quelle che compilerò fra un mese, quindi, mettendo le librerie in GAC rischierei di mandare in crash una applicazione perché la nuova libreria installata con una seconda applicazione ha qualche metodo o qualche classe diversa da quella delle applicazioni precedentemente installate.

Perciò, per chi come me pone tutte le classi base e gli helper comuni a tutti i programmi in una serie di DLL, consiglio l'uso della GAC nelle installazioni se e solo se siete così disciplinati da essere certi al cento per cento che una applicazione installata con la build 1.0 funzioni anche con la 2.0, oppure, siate così bravi da inserire il file di configurazione applicazione che indichi in modo specifico la versione della libreria da usare.

A livello di sviluppo software invece, la GAC è molto utile ed io la uso sul mio PC per tutte le librerie comuni alle mie applicazioni in fase di sviluppo, infatti in questo modo è possibile trovare tutte le librerie automaticamente caricate nel tab .NET della form di inserimento dei riferimenti invece di doverle andare a cercare nei meandri delle cartelle ove abbiamo annidato i nostri progetti. Inoltre quando modifico una libreria di base, basta ricompilare tutte le applicazioni e sono aggiornate con la nuova versione, inoltre immediatamente mi danno errore se ho combinato qualche disastro eliminando/rinominando metodi e classi e sicuramente mi accorgo subito se le modifiche alla DLL vanno a fare esplodere i programmi che le usano, soprattutto se sono così brava da utilizzare gli Unit Test.

Questa è la lista di alcune delle mie librerie installate in GAC, però, per far comparire le librerie in questa lista, non basta semplicemente registrarle in GAC, perché Visual Studio è un po' cattivello e per comporre questa lista, ha bisogno di una chiave sul registry che gli indica quali sono le cartelle su cui andare a leggere le librerie della GAC.

La chiave del registry in questione si trova sotto

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\AssemblyFolders\

Come potete vedere è necessario creare una chiave su questa cartella, il cui valore contiene il percorso su cui si trovano le nostre DLL registrate in GAC. Lo script per creare questa chiave sul registry è il seguente:

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\AssemblyFolders\NomeAzienda.Nomechiave]
@="C:\\CartellaDelleDllInGAC"

Se osservate l'immagine, per la chiave relativa alle mie librerie, ho imitato Infragistics (impariamo da chi c'è da più tempo di noi) chiamando la chiave con il Nik della mia azienda, il tipo di dll (Win/Web) e la versione delle stesse. Il nome della cartella ovviamente è il path completo della cartella dove si trovano le DLL.

Visto che andare a modificare chiavi sul registry è qualcosa da fare con un po' di attenzione, per non dover registrare una per una tutte le cartelle dei miei progetti DLL, ho creato un unica cartella dove pubblico le DLL che registro in cache.
A questo punto, l'obiezione è "Ma che noia, copiare la libreria a manina sulla cartella e poi registrarla in GAC".
Per evitare le cose noiose i programmatori sono bravissimi e quelli di Microsoft hanno predisposto sui progetti di Visual Studio il necessario per darci una mano.

Ciò che possiamo usare per automatizzare queste operazioni sono i Post Build Events di Visual studio, in VB non li avevano messi nella versione 2003 (lo so lo so vi maltrattano), ma nella versione 2005 si sono resi conto che in VB non si fanno solo programmini da dilettanti quindi sono stati aggiunti, un pochino nascosti ma li trovate qui.

La finestra si apre con il tastino che ho evidenziato e permette di gestire sia cose da fare prima di compilare che cose da fare dopo. Le cose da fare prima potrebbero ad esempio essere l'aggiornare dei files di contenuti (magari gli help e altro) che non sono di nostra competenza e devono essere aggiornati automaticamente. Nelle cose da fare dopo invece una delle più utili è l'automatizzazione della pubblicazione, che può anche essere un mezzo per inserire in un area comune a tutti gli sviluppatori delle DLL aggiornate di un team, in modo che ciascuno possa scaricarle in locale e usarle.

Prima di vedere come fare a realizzare il tutto, vediamo anche la versione C# (un po' meno nascosta)

Per darci ancor più una mano, i programmatori di Microsoft ci permettono di inserire negli script che possiamo chiamare prima e dopo la compilazione, una serie di Macro per recuperare dati relativi all'ambiente e al progetto senza dover riscrivere tutto a manina. Basta fare click sul bottone Edit Post-Build e appare questa finestra:

Vi invito a curiosare e provare le varie opzioni per vedere l'effetto che fanno... Vediamo che cosa ho scritto io sul mio mini script:

call ..\..\publish.bat $(ConfigurationName) $(TargetName)

call è un comando batch della console, serve per chiamare un file batch da un altro file batch perché in realtà questi script non sono altro che dei Batch di comandi.

..\..\publish.bat è il nome del file batch in cui ho inserito i comandi per la pubblicazione, il motivo del ..\..\ è che quando viene eseguita la chiamata, il sistema ha come current directory la cartella bin\debug oppure bin\release, pertanto dobbiamo risalire 2 livelli per trovare il file batch (uno solo per tutti) con i comandi per la pubblicazione che io ho inserito nella cartella di progetto.

$(ConfigurationName) vale Debug o Release in base alla configurazione da noi scelta per la compilazione e ci aiuterà a comporre il nome della cartella ove si trova la dll da pubblicare.

$(TargetName) E il nome dell'assembly che ci servirà per costruire i dati per pubblicare e registrare in GAC la nostra libreria.

Ed ora, l'ultimo oggetto da esplorare, il file Batch publish.bat.

cd ..\.. 
call %windir%\system32\xcopy.exe bin\%1\%2.dll "C:\DllPublish\*.*" /s/e/v/y 
call %windir%\system32\xcopy.exe bin\%1\%2.xml "C:\DllPublish\*.*" /s/e/v/y 
call "%ProgramFiles%\Microsoft Visual Studio 8\SDK\v2.0\Bin\gacutil.exe" /u %2 
call "%ProgramFiles%\Microsoft Visual Studio 8\SDK\v2.0\Bin\gacutil.exe" /i bin\%1\%2.Dll

Questo batch è stato creato in modo da essere generico, funziona copiandolo e incollandolo su un qualsiasi progetto di tipo DLL, vediamo in dettaglio che cosa fa:

cd ..\.. 
Questo comando sposta la current directory allo stesso livello del file batch

%windir%
il comando %nome% rileva una delle Environment Variables che sono visibili dalla console dei comandi digitando
c:\> SET

In questo caso leggiamo la cartella di installazione di Windows, per comporre il luogo ove si trova il comando xcopy.exe

bin\%1\%2.dll

Il comando %n viene sostituito dal parametro della linea di comando passato al Batch file quindi in questo caso componiamo il nome della cartella e il nome della dll (ES. bin\Release\Mylibrary.dll)

%ProgramFiles%

Questo comando, legge dove si trova la cartella Programmi del sistema per comporre il nome della cartella ove si trova l'utility di registrazione in GAC delle DLL

Dopo aver spiegato le cose strane, vediamo come il nostro batch:

sposta la cartella corrente sulla cartella di progetto,
copia la DLL e il suo file di documentazione XML (che servirà per avere l'intellisense quando faremo ad essa riferimento nei nostri progetti) nella cartella di pubblicazione da noi scelta.
rimuove dalla GAC la DLL
registra in GAC la DLL

Con questa serie di "Barbatrucchi", otteniamo di risparmiarci delle noiose operazioni nello sviluppo di progetti complessi, provo ad elencarne alcuni:

Trasformiamo le nostre librerie di base in una suite di oggetti a nostra disposizione per tutti i progetti. (se volete un esempio di cosa mettervi dentro leggete Guarda, Senza Mani! ove abbiamo creato una struttura di librerie riusabili).
Abbiamo le librerie sempre a disposizione nel tab .NET per farvi riferimento.
Le nostre librerie in GAC sono tenute sempre aggiornate all'ultima versione.
Aggiungere una nuova libreria al gruppo delle librerie pubblicate è questione di qualche click, dobbiamo copiare e incollare il file batch publish.bat sulla cartella di progetto e aggiungere la riga di comando al Post Build Event.

IMPORTANTE!

Perche una libreria possa essere registrata in GAC deve essere dotata di uno Strong Name, ovvero deve essere firmata con una Chiave Binaria, per farlo, andate a guardare il tab Signing delle proprietà di progetto (usualmente l'ultimo nello stesso luogo ove abbiamo trovato i post build events).

Prometto che farò un post in merito in seguito.

Spero di esservi stata utile, per qualsiasi errore o domanda, approfondimento, delucidazione, il modulo di feedback è in fondo al post.

Tags: GAC, Strongname

Scrivere nel registry usando come scusa le sorgenti dati ODBC (Storico)

Sabrina C. — Mon, 24 Mar 2008 17:59:55 GMT

Ecco il secondo post dedicato al registry, nel primo che trovate qui ho mostrato come leggere chiavi e valori dal registry, in questo post, genero una nuova origine dati ODBC generando una chiave e aggiungendo valori a 2 chiavi del Registry.

Abbiamo visto come una origine dati ODBC, non sia altro che una serie di dati memorizzati nel registro di sistema, e abbiamo visto che .NET ci fornisce due oggetti per lavorare con il registry:

La classe statica Registry che permette di accedere al registro di sistema e di leggere velocemente le sottochiavi principali, LocalMachine e CurrentUser, e la classe RegistryKey che ci permette di generare una chiave di registro, leggere una chiave esistente, aggiornare o generare valori per una chiave di registro.

Per vedere come si genera una origine dati ODBC, alla form del progetto di test aggiungiamo 2 bottoni che chiameremo: btnGenOdbcNwSys e btnGenOdbcNwUser. Facciamo anche una modifica ai primi 2 bottoni che abbiamo generato e trasformiamo il contenuto di ciascuno in un metodo, trasformando in questo modo il codice:

        private void btnLeggiODBC_Click(object sender, EventArgs e)
        {
            LeggiOdbcSys();
        }

        private void LeggiOdbcSys()
        {
            RegistryKey regKeySys = Registry.LocalMachine.CreateSubKey("Software\\ODBC\\ODBC.INI");
            //RegistryKey[] subKeys = regKey.GetSubKeyNames();

            string[] keys = regKeySys.GetSubKeyNames();
            StringBuilder sb = new StringBuilder();
            sb.AppendLine(new string('-', 30));
            sb.AppendLine("Lista ODBC di sistema trovati:");
            for (int i = 0; i < keys.Length; i++)
            {
                sb.AppendLine(keys[i]);
                RegistryKey odbcKey = regKeySys.OpenSubKey(keys[i]);
                string[] valueNames = odbcKey.GetValueNames();
                for (int j = 0; j < valueNames.Length; j++)
                {
                    sb.AppendFormat("* \t {0}={1}", valueNames[j], odbcKey.GetValue(valueNames[j]).ToString());
                    sb.AppendLine();
                }
            }
            sb.AppendLine(new string('-', 30));
            sb.AppendLine();
            this.txtResult.Text = sb.ToString() + this.txtResult.Text;
        }

Facciamo lo stesso con il bottone che visualizza gli ODBC Utente, non ricopio il codice perché è ripetitivo, ma lo trovate sul progetto allegato.

Veniamo ora alla funzione che ci interessa veramente, Questa funzione, genererà una origine dati ODBC fra le origini dati di sistema che si connette al database Northwind su un Server SQL 2005.

        private void btnGenOdbcNwSys_Click(object sender, EventArgs e)
        {
            string name = "TestNorthwindSys";
            RegistryKey regKeySysOdbcDrv = Registry.LocalMachine.CreateSubKey(string.Format("Software\\ODBC\\ODBC.INI\\{0}", name));
            RegistryKey regKeySysOdbcList = Registry.LocalMachine.CreateSubKey("Software\\ODBC\\ODBC.INI\\ODBC Data Sources");

            regKeySysOdbcDrv.SetValue("Database", "Northwind" );
            regKeySysOdbcDrv.SetValue("Description", "Test Odbc Northwind Sys" );
            regKeySysOdbcDrv.SetValue("Language", "Italiano" );
            regKeySysOdbcDrv.SetValue("Server", "myComputer" );
            regKeySysOdbcDrv.SetValue("Trusted_connection", "Yes" );
            regKeySysOdbcDrv.SetValue("Driver", "sqlncli.dll" );

            regKeySysOdbcList.SetValue( name, "Sql Native Client" );

            LeggiOdbcSys();
        }

Questo codice, genera una nuova chiave che si chiama TestNorthwindSys come figlia della chiave contenente gli ODBC di sistema, genera una serie di valori che la definiscono sempre agganciati alla chiave TestNorthwindSys, e infine aggiunge la nuova origine dati ed il nome del suo Driver alla lista degli ODBC di sistema usando la chiave ODBC Data Sources posta sotto la chiave principale degli ODBC.

Aggiungiamo lo stesso tipo di funzionalità però sulle origini dati Utente:

        private void btnGenOdbcNwUser_Click(object sender, EventArgs e)
        {
            string name = "TestNorthwindUsr";
            RegistryKey regKeySysOdbcDrv = Registry.CurrentUser.CreateSubKey(string.Format("Software\\ODBC\\ODBC.INI\\{0}", name));
            RegistryKey regKeySysOdbcList = Registry.CurrentUser.CreateSubKey("Software\\ODBC\\ODBC.INI\\ODBC Data Sources");

            regKeySysOdbcDrv.SetValue("Database", "Northwind");
            regKeySysOdbcDrv.SetValue("Description", "Test Odbc Northwind Sys");
            regKeySysOdbcDrv.SetValue("Language", "Italiano");
            regKeySysOdbcDrv.SetValue("Server", "myComputer");
            regKeySysOdbcDrv.SetValue("Trusted_connection", "Yes");
            regKeySysOdbcDrv.SetValue("Driver", "sqlncli.dll");

            regKeySysOdbcList.SetValue(name, "Sql Native Client");

            LeggiOdbcUser();

        }

Abbiamo cambiato il nome dell'ODBC e abbiamo cambiato la Root Key da Local Machine a CurrentUser, ma il codice è sempre lo stesso.

Se provate a premere i bottoni sulla form e poi aprite la Gestione Origini Dati ODBC sul pannello di controllo, troverete le due nuove connessioni che possono essere testate e risultano funzionanti.

N.B. E' indispensabile cambiare il parametro Server con il nome del vostro PC o comunque il nome dell'istanza di SQL Server a cui vi collegate.

Questo esempio utilizza una chiave del registry ben precisa, però con lo stesso metodo è possibile generare ed aggiornare chiavi del registry a qualunque liverllo, ovviamente se e solo se, l'utente che esegue il programma ha i necessari diritti per poterlo fare.

Sono certa che far girare questa applicazione con un utente non amministratore della macchina provocherà una serie di eccezioni.

il link al progetto di test lo trovate qui

Qualunque domanda, osservazione, correzione, anatema, sarà bene accetto.

Tags: registry, classi

Curiosare nel registry usando come scusa le sorgenti dati ODBC (Storico)

Sabrina C. — Mon, 24 Mar 2008 17:58:03 GMT

Un paio di giorni fa, qualcuno ha chiesto sul forum come si genera da programma una origine dati ODBC, sapendo che il mio collega il Sistemaio usualmente inserisce nei login script la generazione delle origini dati ODBC necessarie al lavoro quotidiano degli utenti, gli ho chiesto se poteva darmi gli script, ovviamente, i suoi script sono in VBA visto che vengono eseguiti dal sistema al login, pertanto li ho presi come spunto per questo post, in cui vedremo come esaminare le origini dati ODBC che esistono su una macchina siano esse ODBC di sistema oppure ODBC Utente, usando .NET al posto di VBA. Ne seguirà un'altro, forse due, che mostreranno come generare l'origine dati ODBC da .NET

Nello script del Sistemaio, nella sezione che genera gli ODBC di sistema c'era il seguente codice:

cRegKey1 = "HKLM\Software\ODBC\ODBC.INI\" & trim(ssNome) & "\"
cRegKey2 = "HKLM\Software\ODBC\ODBC.INI\ODBC Data Sources\"

Assomigliano molto a due chiavi del registry, e il prefisso HKLM sembra indicare HKey Local Machine, quindi, ne deduciamo che per vedere quali ODBC sono definiti su di un PC abbiamo bisogno di una chiave del registry. Visto che entrambe le chiavi qui sopra si trovano sotto ODBC\ODBC.INI, questa chiave sarà l'oggetto della mia curiosità:

Il progetto di test, solo in C#, lo trovate in Area Download.

La soluzione OriginiDatiODBC contiene un solo progetto WindowsForms con lo stesso nome, in cui è una sola form FrmMain. Nella form ho inserito i seguenti controlli:

uno split container, due bottoni nel pannello 1, una textbox multilinea nel pannello 2 che riempie tutto il pannello.

Il primo bottone, btnLeggiODBC, ha il seguente codice sull'evento click:

        private void btnLeggiODBC_Click(object sender, EventArgs e)
        {
            RegistryKey  regKeySys = Registry.LocalMachine.CreateSubKey( "Software\\ODBC\\ODBC.INI" );
            string[] keys = regKeySys.GetSubKeyNames();
            StringBuilder sb = new StringBuilder();
            sb.AppendLine(new string('-', 30)); 
            sb.AppendLine("Lista ODBC di sistema trovati:");
            for( int i=0; i< keys.Length; i++ )
            {
                sb.AppendLine(keys[i]);
                RegistryKey odbcKey = regKeySys.OpenSubKey(keys[i]);
                string[] valueNames = odbcKey.GetValueNames();
                for (int j = 0; j < valueNames.Length; j++)
                {
                    sb.AppendFormat("* \t {0}={1}", valueNames[j], odbcKey.GetValue(valueNames[j]).ToString());
                    sb.AppendLine();
                }
            }
            sb.AppendLine(new string('-', 30));
            sb.AppendLine();
            this.txtResult.Text = sb.ToString() + this.txtResult.Text;
        }

Cosa abbiamo fatto? Un metodo che lista tutte le chiavi del registry che si trovano su LocalMachine\Software\ODBC\ODBC.INI, per farlo utilizziamo le classi RegistryKey e Registry che si trovano in Microsoft.Win32, Apriamo la chiave contenente i dati dell'ODBC, usando il metodo CreateSubKey della proprietà LocalMachine dell'oggetto Registry.

Fatto questo, per listare che cosa c'è dentro alla chiave relativa agli ODBC, usiamo il metodo GetSubKeyNames per ottenere i nomi di tutte le chiavi che si trovano sotto alla chiave principale. Proseguiamo poi preparando uno stringbuilder che ci permetterà di visualizzare il contenuto del registry, ed infine facciamo un ciclo sulla lista delle chiavi che abbiamo recuperato e per ognuna di esse, usiamo il metodo OpenSubKey per ottenere l'oggetto RegistryKey, e la funzione GetValueNames per ottenere tutti i nomi dei valori presenti in ciascuna delle chiavi, con un ciclo annidato aggiungiamo allo StringBuilder i nomi dei valori ed il loro valore (non è un gioco di parole).

Cosa otteniamo facendo click sul nostro bottone? Una lista di questo tipo:

------------------------------
Lista ODBC di sistema trovati:
4UAHR
* Database=4UAHR
* Description=AHR - For You I.T.
* Driver=\sqlncli.dll
* Language=Italiano
* Server=4unb10
* Trusted_Connection=Yes
DBMIRROR
* Driver=C:\WINDOWS\system32\sqlncli.dll
* Description=Connessione al DBMIRROR MEXAL
* Server=rddev
* Database=DBMIRROR
* LastUser=scosolo
* Trusted_Connection=Yes
GlobalCar
* DBQ=C:\Programmi\Macromedia\Dreamweaver MX\Samples\Database\global.mdb
* Description=Data Source for the Compass Travel tutorial site.
* Driver=C:\WINDOWS\system32\odbcjt32.dll
* DriverId=25
* FIL=MS Access;
* SafeTransactions=0
* UID=
ODBC Data Sources
* DBMIRROR=SQL Native Client
* GlobalCar=Microsoft Access Driver (*.mdb)
* PUBS=SQL Native Client
* 4UAHR=SQL Native Client
ODBC File DSN
* DefaultDSNDir=C:\Programmi\File comuni\ODBC\Data Sources
PUBS
* Driver=C:\WINDOWS\system32\sqlncli.dll
* Description=Connect to Pubs Database
* Server=4unb10
* Database=pubs
* LastUser=scosolo
* Trusted_Connection=Yes
------------------------------

Quelle contrassegnate in Azzurro, sono le origini dati ODBC di sistema inserite sul mio PC, ciascuna contiene al suo interno come valori le seguenti informazioni:

Il Driver, usualmente una DLL che si trova su WINDOWS\System32, poi dei parametri diversi a seconda del tipo di driver, in questo caso sono di 2 soli tipi, driver per SQL Server 2005 e il driver per il tutorial di DreamWeaver MX che invece è un file access. Ogni origine dati ha una Descrizione, ed alcuni parametri variabili che permettono al driver di comporre la stringa di connessione a quel tipo di sorgente dati.

Le chiavi contrassegnate in Rosso, non sono origini dati, sono invece delle chiavi di configurazione per la gestione degli ODBC, infatti, ODBC Data Sources contiene la lista degli ODBC con il nome del driver ad essi associato, mentre ODBC File DSN contiene la cartella che ospita i DSN salvati su file.

Il secondo bottone btn_LeggiODBCUsr, fa qualcosa di simile a quel che fa il primo bottone, però, invece di partire da LocalMachine, parte da CurrentUser, l'oggetto che rappresenta i dati di configurazione del registro per l'utente correntemente loggato. Questo, ci permette di ottenere ed osservare, i dati di configurazione ODBC utente.

        private void btnLeggiODBCUsr_Click(object sender, EventArgs e)
        {
            RegistryKey regKeyUsr = Registry.CurrentUser.CreateSubKey("Software\\ODBC\\ODBC.INI");
            StringBuilder sb = new StringBuilder();
            sb.AppendLine(new string('-', 30));
            sb.AppendLine("Lista ODBC utente trovati:");
            string[]  keys = regKeyUsr.GetSubKeyNames();
            for (int i = 0; i < keys.Length; i++)
            {
                sb.AppendLine(keys[i]);
                RegistryKey odbcKey = regKeyUsr.OpenSubKey(keys[i]);
                string[] valueNames = odbcKey.GetValueNames();
                for (int j = 0; j < valueNames.Length; j++)
                {
                    sb.AppendFormat("* \t {0}={1}", valueNames[j], odbcKey.GetValue(valueNames[j]).ToString());
                    sb.AppendLine();
                }
            }
            sb.AppendLine(new string('-', 30));
            sb.AppendLine();

            this.txtResult.Text = sb.ToString() + this.txtResult.Text;

        }

Anche questo metodo, come il precedente utilizza le classi Registry, RegistryKey, ed i metodi CreateSubKey, GetSubKeyNames, OpenSubKey, GetValueNames, GetValue per ottenere le informazioni sul contenuto della chiave del Registry e dei suoi sottolivelli che a noi interessano.

Cosa otteniamo premendo il tasto sulla form?

------------------------------
Lista ODBC utente trovati:
ahrdemo
* Driver=C:\WINDOWS\system32\SQLSRV32.dll
* Description=ADHOC REVOLUTION
* Server=(local)
* Database=ahrdemo
* LastUser=sa
* Trusted_Connection=Yes
dBASE Files
* UID=
* SafeTransactions=0
* DriverId=533
* Driver=C:\PROGRA~1\FILECO~1\MICROS~1\OFFICE12\ACEODBC.DLL
Excel Files
* UID=
* SafeTransactions=0
* DriverId=1046
* Driver=C:\PROGRA~1\FILECO~1\MICROS~1\OFFICE12\ACEODBC.DLL
MS Access Database
* UID=
* SafeTransactions=0
* DriverId=25
* Driver=C:\PROGRA~1\FILECO~1\MICROS~1\OFFICE12\ACEODBC.DLL
ODBC Data Sources
* Visio Database Samples=Microsoft Access Driver (*.MDB)
* ahrdemo=SQL Server
* dBASE Files=Microsoft Access dBASE Driver (*.dbf, *.ndx, *.mdx)
* Excel Files=Microsoft Excel Driver (*.xls, *.xlsx, *.xlsm, *.xlsb)
* MS Access Database=Microsoft Access Driver (*.mdb, *.accdb)
Visio Database Samples
* SafeTransactions=0
* DefaultDir=""
* DBQ=C:\PROGRA~1\MICROS~2\Visio11\1040\DBSAMPLE.MDB
* DriverId=25
* Driver=C:\WINDOWS\system32\\odbcjt32.dll
* UID=
* ReadOnly=System.Byte[]
------------------------------

Anche in questo caso, in Blu abbiamo gli ODBC utente memorizzati sulla macchina e invece in rosso abbiamo la chiave ODBC Data Sources che contiene la lista degli ODBC ed il nome del driver ad essi associato.

Facciamo il riassunto di quello che abbiamo scoperto con la scusa della gestione degli ODBC:

Il namespace Microsoft.Win32 che contiene classi per la gestione del sistema
la classe statica Registry che fornisce proprietà che danno accesso alle principali chiavi del registro di sistema
- LocalMachine Proprietà statica che fornisce l'accesso a HKey Local Machine
- CurrentUser Proprietà statica che fornisce l'accesso a HKey Current User
la classe RegistryKey che permette di aprire e leggere una chiave di registro e ottenere informazioni o fare modifiche sulla chiave letta.
il metodo CreateSubKey che permette di aprire una chiave esistente sul registro oppure di generarne una nuova.
il metodo GetSubKeyNames che permette di ottenere una lista delle sottochiavi di una chiave di registro (se ne è provvista)
il metodo GetValueNames che permette di ottenere una lista dei nomi dei valori di una chiave di registro (se ne è provvista)
il metodo GetValue che permette di ottenere il valore di un valore (uff!) di una chiave di registro.

Nel prossimo post, proveremo a generare una origine dati ODBC nuova e vedere l'effetto che fa...

Tags: registry, classi