Gestione Dati

Installare SQL Server 2008 Express Edition su Windows 2008 R2 64bit

Sabrina C. — Wed, 14 Sep 2011 17:21:40 GMT

Un Webcast di tipo Sistemistico per spiegare come installare SQL Server Express edition configurandolo in modo professionale, era dai tempi di MSDE che non replicavo questo tipo di post, pertanto ho ritenuto opportuno farlo, soprattutto perché mi sono trovata da un paio di clienti ove ho trovato la classica installazione Avanti –> Avanti –> Invio e quindi ho creduto opportuno dare modo anche a chi non è un sistemista esperto di sapere come e soprattutto perché fare determinate operazioni quando si installa SQL Server. Replicherò anche con una versione non express prossimamente, aggiungendo anche la parte di configurazione degli utenti di servizio.

Tag di Technorati: SQL,Install,SqlExpress

A questo indirizzo potete scaricare il webcast.

Lavorare con dati di grandi dimensioni in SQL Server

Sabrina C. — Mon, 02 May 2011 19:48:10 GMT

Come promesso al workshop di Pordenone dello scorso 28 Aprile 2011, ho preparato il webcast del primo dei miei due interventi, quello relativo alla manipolazione di dati binari di grandi dimensioni su database SQL Server usando la scrittura e la lettura per Segmenti (Chunks).

In questo webcast composto da una parte spiegata su powerpoint e una seconda parte che mostra i punti principali del progetto demo a corredo, spieghiamo come fare a Scrivere su campi di tipo Image o di tipo VarBinary(max) suddividendo i dati binari in segmenti per poter gestire la memorizzazione di files di grandi dimensioni in un database.

Codice a corredo: sqlchunks.zip

Tag di Technorati: c#,sql,tsql,sqlserver,image,varbinary

Lezioni di "pesca" .Net in C# parte 3

Sabrina C. — Sat, 30 Apr 2011 10:22:43 GMT

Nel terzo webcast della serie che ho chiamato “Non Solo Hello World”, proseguiamo lo sviluppo della nostra applicazione di test iniziando a vedere qualcosa di più sofisticato nella nostra classe dati di base e qualcosa di più sofisticato a livello di interfaccia.

Risponderemo con una prima versione alla domanda: “Ma come posso salvare dei dati digitati su schermo e persisterli su disco.”

E vedremo come realizzare una Form che inizi a fornirci i servizi di base per gestire una lista di oggetti su cui compiere le azioni classiche di Nuovo, Modifica, Visualizza.

Approfitto di questo post per ringraziare le oltre ottanta persone che hanno visualizzato i due webcast già pubblicati, consumando la pur generosa banda offerta dall’account gratuito di Screencast.com in pochissimo tempo. Ho già provveduto ad estendere l’account ad una versione Pro, per darvi modo di vedere i webcast senza limitazioni.

Grazie ancora e “Buona Pesca”.

Tag di Technorati: C#,classi,I/O,ListView

Il codice a corredo della terza lezione

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

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

Debug remoto da Visual Studio 2010 alcuni suggerimenti dal mondo reale.

Sabrina C. — Sun, 17 Oct 2010 14:18:18 GMT

Questo è un post fantasma, io scrivo per ritrovare le note quando servirà, ma sono solo un amanuense, il vero esperimento è stato fatto da Luca, il mio collega che ama moltissimo scrivere codice, ma odia scrivere documentazione, blog, articoli e parlare alle pubbliche conferenze… ho sempre la speranza di convincerlo almeno a scrivere un blog, ma le possibilità sono scarse.

Ad ogni modo ecco il come si fa:

Avevamo un comportamento anomalo su una macchina per una applicazione appena installata, la macchina era su un dominio diverso da quello dei PC di sviluppo e volendo fare un remote debug, ecco quello che abbiamo fatto:

Sulla macchina remota, quando si apre l’applicazione mswsmon, ovvero il remote debugger, sul menu Tools>options si può scegliere fra:

Nessuna autenticazione
Autenticazione windows

Provando con la prima, si può debuggare, ma non siamo stati in grado di caricare i debug symbols, pertanto cercare il problema non era proprio semplice senza il codice, anche copiando in locale i files .pdb sulla cartella di installazione non si vedevano i simboli.

Per poter usare quindi l’opzione 2 abbiamo dovuto fare una serie di cose che elenco di seguito:

Creare un utente locale con stesso nome e stessa password su entrambe le macchine, dandogli privilegi di amministratore (in verità sulla macchina remota crediamo bastino privilegi di Remote Debug.)
Disattivare i firewall di entrambe le macchine (siamo certi che basta attivare qualche porta, ma essendo nella stessa rete e nello stesso ufficio, questo era più facile.)
Usando mswsmon sulla macchina remota, loggati con l’utente che poi doveva far girare l’applicazione, abbiamo creato un server chiamato: NomeUtente@Nomemecchina, dove NomeUtente era il nome dell’utente locale creato precedentemente.
Loggarsi sulla macchina di sviluppo con l’utente locale e relativa password, aprire Visual Studio 2010, aprire il debug remoto usando Debug>Attach to process e scegliere:

Transport = default(Windows Authentication)
Qualifier = NomeUtente@Nomemacchina (quelli del punto 3)
Cercare il processo, fare doppio click e confermare.
A questo punto siamo attaccati al processo sulla macchina remota e possiamo debuggarlo.

Abbiamo verificato anche che se abbiamo la medesima versione del programma su entrambe le macchine, se non ci sono i .pdb sulla macchina remota, è possibile usare la finestra Debug>Windows>Modules per cercare la dll o l’exe a cui siamo attaccati e usando il menu contestuale, con il tasto destro, si può caricare i simboli da un file sulla macchina di sviluppo.

Technorati Tag: VS2010,remote debug

Cambio dell’owner di un database

Sabrina C. — Sat, 16 Oct 2010 15:07:28 GMT

Oggi sto facendo una operazione davvero rarissima, ovvero sto spostando server e computer da un dominio windows ad uno completamente nuovo.

Spostando un server con installato SQL Server 2008 dopo lo spostamento sono andata ad aggiornare tutte le mappature dei login su Gruppi/Utenti di dominio e andando a controllare delle cose su di un database attivando l’opzione “Properties” del database, ho avuto un messaggio di errore che mi diceva che, non essendoci un Owner valido sul database non era possibile effettuare l’operazione da me richiesta.

L’owner del database, viene settato al momento della creazione del database ed è usualmente l’utente che ha creato il database. Se chi crea il database è loggato con una trusted connection o comunque come utente di dominio, lo spostamento del server su un altro dominio provoca una incongruenza su questo database.

Per risolvere il problema è necessario cambiare l’owner del database, io ho rimappato tutti i database sull’ utente SQL sa in modo che semmai dovesse succedere nuovamente qualcosa del genere non ci sono simili problemi.

lo script per il change ownership è molto molto semplice:

use NomeDatabase
exec sp_changedbowner 'sa'

Technorati Tag: SQL,TSQL,Database

Configurare SQL Server Database Mail per l’invio delle Notifiche dei Job

Sabrina C. — Thu, 16 Sep 2010 13:51:02 GMT

Oggi dovevo modificare la configurazione del servizio di notifica dei Job di uno dei server SQL dell’azienda, pertanto ho approfittato della cosa per configurare lo stesso servizio su un altro server che fino ad oggi non lo aveva attivo.

Essendo una operazione che si fa una tantum più o meno ogni 5 anni, riporto gli screenshot di come si fa, in modo da poter fare lo stesso sui server dei clienti per verificare che tutto funzioni.

Ho configurato un SQL 2008 ma è lo stesso su SQL 2005.

Aprire la cartella Management, Selezionare Database Mail.

Lasciare l’opzione come configurata se è la prima configurazione altrimenti usare l’opzione più opportuna. e premere NEXT.

Dare al profilo un nome significativo, o un nome che vi piace e una adeguata descrizione, dato che il sistema di DB Mail può essere usato anche per altri scopi oltre che per le notifiche dei job, è possibile generare più profili così come è possibile generare più Accounts di posta.

Fate click sul tasto Add per creare l’account di posta da usare per l’invio delle e-mail, fate attenzione che se ne esiste già uno, non compare immediatamente questa finestra ma compare una finestra che permette di selezionare un account esistente o, premendo un tasto apposito di aprire questa finestra.

Compilate i dati dell’account con un nome e una descrizione significativa, assegnate gli indirizzi di e-mail indicate il nome del server e le credenziali di autenticazione quando siano necessarie oppure, lasciate l’autenticazione anonima (ad esempio se il server SMTP è interno all’azienda e configurato per il login anonimo).

A questo punto, è necessario indicare i dati si sicurezza per il profilo, per poter spedire le e-mail dall’Agent che è colui che esegue i job, è opportuno che il profilo sia Pubblico, non Privato.

A questo punto, ci saranno mostrate 2 schermate di verifica e conferma esecuzione, proseguiamo con NEXT per arrivare a quento mostrato qui sopra.

Spostiamoci ora nella cartella Operators che si trova all’interno degli oggetti del Sql Server Agent. E creiamo un nuovo Operatore.

Ci basta indicare il nome dell’operatore e la e-mail a cui spedire le notifiche, a meno che non vogliate usare anche Net Send ed il Pager.

In ciascuno dei JOB di Backup, Manutenzione, Esecuzione script o qualsiasi altro tipo di funzionalità, indichiamo l’operatore appena generato, l’uso della e-mail e se vogliamo notificargli Solo gli errori, Tutto oppure solo le esecuzioni andate a buon fine.

A questo punto, facciamo tasto destro sull’icona dell’Agent e selezioniamo Alert System, andando ad attivare il profilo di posta che abbiamo generato. Se non si effettua questa operazione, l’agent non invierà mai alcuna notifica via e-mail.

Una volta terminata la configurazione, facciamo ripartire SQL Server Agent per permettergli di attivare le modifiche alla configurazione del sistema di Alert.

Da ora in poi, i JOB in cui abbiamo inserito le notifiche, ci avviseranno di qualsiasi cosa accade.

Possiamo inoltre attivare la notifica per ogni tipo di Alert.

Tags: SQLServer 2008, Job, Alert, Database Mail

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

Come generare un Guid.Empty in SQL

Sabrina C. — Tue, 10 Aug 2010 21:05:11 GMT

Venerdì scorso, il mio collega Luca stava litigando con un problema determinato da valori null, DbNull e Guid in una classe che si occupa di effettuare query su Database.

La classe Guid, è una classe di tipo Value Type, pertanto non è nullabile. Per contro, nelle Stored Procedure, io utilizzo il valore DbNull come indicatore di Default per indicare che un parametro di filtro è vuoto e deve quindi essere ignorato.

Modificare parecchie classi C# per trasformare il Guid in un Nullable Guid diveniva complicato e non facile da gestire e aggiornare, pertanto abbiamo provato a ragionare ed è risultato che se avessimo potuto usare un Guid.Empty nelle nostre stored procedure (o nelle query ad hoc), avremmo risolto il problema senza complicate manovre.

Facendo varie prove siamo stati in grado di produrre la seguente Scalar Function:

CREATE FUNCTION Guid_Empty()
RETURNS UniqueIdentifier
AS
BEGIN
RETURN cast(cast(0 as binary) as uniqueidentifier)
END
GO

Dopo aver generato la funzione qui sopra ed una semplice tabella nel mio famigerato database di test, sono stata in grado di scrivere la query seguente:

SELECT [ID]
      ,[Descrizione]
      ,[Prezzo]
      ,[Quantità]
      ,[Umi]
      ,IsNull(AltGuid, dbo.Guid_EMPTY()) AS Alt
  FROM [paperinik].[dbo].[TbRighe]

Che produce la seguente tabella risultante:

Posso inoltre usare la mia funzione per creare la query seguente:

SELECT [ID]
      ,[Descrizione]
      ,[Prezzo]
      ,[Quantità]
      ,[Umi]
      ,IsNull(AltGuid, dbo.Guid_EMPTY()) AS Alt
  FROM [paperinik].[dbo].[TbRighe]
WHERE
IsNull(AltGuid, dbo.Guid_EMPTY()) = dbo.Guid_EMPTY()

Che mi permette di filtrare le righe con Guid.Empty oppure posso usare l’operatore <> per cercare le sole righe con un Guid non vuoto. Usando questo tipo di Query, posso tranquillamente passare come parametro il Guid.Empty di C# come filtro senza la necessità di creare un Guid nullable o implementare complicate espressioni di controllo nelle mie classi.

Technorati Tag: SQL,C#,Guid