IEnumerable - Il blog personale di Andrea Balducci

Libero professionista vs Dipendente

admin — Mon, 25 Jul 2011 07:15:04 GMT

Le statistiche di xobni offrono interessanti spunti di riflessione.

Q: Quanti sono i dipendenti?

Sviluppare per Windows Mobile su Windows7

admin — Thu, 26 May 2011 08:51:13 GMT

L’emulatore di Windows Mobile richiede per la connettività di rete la presenza del driver distribuito con Virtual PC 2007

Per poter abilitare la rete senza dover installare il driver basta abilitare la connesione DMA con l’emulatore.

Da device emulator manager selezionare l’opzione cradle

A questo punto l’emulatore si connette al pc

Ora la macchina di sviluppo è raggiungibile

Nota: il Mobile Device Center non è troppo smart.. a volte bisogna cambiare la connessione ad usb, confermare e rimetterla a DMA per “fargli sentire” il device.. con le buone ;D

Deploy di Orchard su Azure

admin — Wed, 11 May 2011 09:49:18 GMT

Sto testando Orchard su Azure usando l’abbonamento “benefit” di MSDN Premium per un nuovo progetto community. Nei sorgenti di Orchard non è indicato il tipo di dimensione della vm, quindi il buon azure opta per la “small” che ha un costo maggiore di quella inserita nei benefit di MSDN.

Per verificare che tipo di vm state usando basta abilitare l’apposita colonna “Size” nella maschera degli hosted services

Qualora la dimensione dell’istanza non sia conforme con quanto previsto dai benefit MSDN vi troverete addebitato un costo orario differente; in realtà verranno scalate meno ore di quelle effettivamente consumate perché queste “pesano” meno (to be verified)

Per modificare la dimensione della vm bisogna agire sulle proprietà del progetto

o modificare direttamente il file ServiceDefinition.csdef

Buon test a tutti

La strana storia di Quartz, Castle ed NHibernateFacility nel mondo di Lucilla

admin — Tue, 11 Jan 2011 23:08:59 GMT

C’era una volta una applicazione web che aveva in cui i servizi di business logic si godevano beati il loro lifestyle PerWebRequest… finchè un giorno irruppe il prode cavaliere oscuro pronto a prestare i suoi servizi in background… e a scombinare il regno di Lucilla mettendo in crisi i servizi resi orfani del fido custone in HttpContext che teneva gelosamente la session al sicuro…

Panico nel Castello… ed ora che si fa? Calma e gesso disse il re (e chi sarà mai questo re? ;D).. che i servizi cambino stile di vita e diventino Transient(i)!

oohhhhh (questo è vs dopo l’estenuante modifica di 1 parametro nel regno di Lucilla)

Ora il prode Quartz era pronto a sfoderare tutta la sua potenza schierando nelle seconde file i servizi di supporto e le attività pianificate. Ma ecco che allo scoccare della mezzanotte il primo cavaliere cade sconfitto: il custode della session non c’e’ più, è rimasto prigioniero nelle segrete dell’HttpContext.

Panico nel castello… la signora facility giace nel letto di HttpContext e non può soddisfare contemporaneamente anche il CallContext… HttpContext o CallContext, IsWeb=true o IsWeb=False? (http://stw.castleproject.org/Windsor.NHibernate-Facility.ashx)

“IsWeb ‘sta cippa” tuonò il re.. “Facility fa quello che dico io. Si costruisca una nuova stanza per ospitare sia HttpContext che CallContext e che Facility sia sempre pronta a svegliare il custode della session appropriato”…

E tutti vissero felici e contenti.. https://gist.github.com/775282

Intepreti in ordine sparso..
Il re : io me medesimo
Il regno di Lucilla: Lucilla.Framework
Facility: http://stw.castleproject.org/Windsor.NHibernate-Facility.ashx
Il custode in HttpContext: Castle.Facilities.NHibernateIntegration.SessionStores.WebSessionStore
Il custode in CallContext: Castle.Facilities.NHibernateIntegration.SessionStores.CallContextSessionStore
Il cavaliere oscuro: http://quartznet.sourceforge.net/
La nuova stanza dei custodi: Lucilla.Framework.Core.Data.NHFacility.LucillaSessionStore
Tempo di realizzazione: 1/10 di quello impiegato a scrivere questo post.. possibile solo nel regno dell’opensource.

Convertire in automatico il testo con MVC2

admin — Mon, 10 Jan 2011 22:44:35 GMT

Per un applicativo intranet ho la necessità di vincolare il case di alcuni campi del model. Dopo qualche ricerca in google e nessuna fonte ho creato (non senza qualche dubbio architetturale) una prima implementazione quick & dirty.

Trovate il codice qui: https://gist.github.com/773608

Tip: Esecuzione veloce di Unit Test con Resharper

admin — Tue, 04 Jan 2011 23:21:03 GMT

Per lanciare direttamente da tastiera il test corrente (in base al caret) con resharper basta mappare la scorciatoia da tastiera come indicato.

Visual Studio 2010 e ReadyBoost

admin — Sat, 27 Nov 2010 17:30:29 GMT

Avendo una chiavetta usb da 4gb inutilizzata ho deciso di provare ReadyBoost sulla workstation del lavoro (Win 7 x64, Xeon 4 core, doppio Raptor e 4gb di ram).

Questo il grafico per la prima e la seconda esecuzione di vs con un progetto corposo.

Per configurare il monitor seguite questo post http://blogs.msdn.com/b/saveenr/archive/2009/05/02/monitoring-readyboost-on-windows-7.aspx

La percezione dei prodotti

admin — Fri, 10 Sep 2010 17:29:41 GMT

Può un prodotto (o meglio la sua percezione) cambiare le sorti di un’azienda?

Grafico interattivo qui: http://www.google.com/finance?q=NASDAQ:ADBE,+NASDAQ:GOOG,+msft,+aapl

Non credo che l’ascesa di apple sia legata solamente all’avvento dell’iPhone ma sicuramente ha contribuito dalla percezione che gli end-user hanno dei prodotti. Ieri ho consigliato ad un familiare di non acquistare un iPad e di aspettare il Samsung Tab. Risposta : “di samsung ho avuto qualche telefono e mi sono sempre trovato male, con l’iPhone mi sono trovato benissimo. Anche se costa di più prendo l’iPad”. Non è l’unica testimonianza del genere che ho raccolto di persona, anche tra professionisti del settore che campano vendendo migliaia di licenze software in ambiente Microsoft.

Personalmente ho provato MacOS e non riesco ad usarlo per più di cinque minuti, motivo per cui ho sempre girato al largo dalla famiglia Mac “bollandola” da ignorante come una moda.

Poi un giorno sulla poltrona del dentista (forse con la complicità dell’anestesia, chi può dirlo) si è insinuato il tarlo nella testa. Alla classiche domande di circostanza “che lavoro fai?” ho riposto con un generico “roba di informatica”. Rimango sempre sul vago perché poi scatta subito la richiesta di guardare “solo 2 minuti” la connessione internet che non va, la stampante, acrobat, il video, i virus; qualcuno si azzarda anche a “dovrei reinstallare l’office” o “mi si è rallentato tutto, mi hanno detto di formattarlo” (sono tutte richieste ricevute realmente). Ero pronto a ribattere con un “e’ roba da sistemista, io faccio un altro lavoro. E’ come chiedere ad un infermiere di operare al cervello” che solitamente chiude la conversazione quando il medico se ne esce con : “ho acquistato un mac, con windows era sempre un casino. Ora è tutto più semplice, ogni cosa è dove te l’aspetti e non ho problemi.”

Non è stato il primo a recitare “esattamente” quella frase (la mettono forse sul libretto di istruzioni?). Imprenditori affermati, liberi professionisti, studenti, utenti comuni.. tutti sottoposti al lavaggio del cervello, questo era il mio pensiero (arrogante lo ammetto) da “esperto” del settore.

Quel tarlo ha lavorato e lavorato in background fino a che non mi sono detto: “E se avessero ragione?”. Se fossi io prevenuto e perdessi un’opportunità? Mi sono rimesso in gioco, si parte da zero su un terreno che non conosco: ho acquistato iPad e sono soddisfatto del prodotto (anche se di cose ne cambierei nell’os, confido in iOS 4.2). Ora tocca all’iPhone4 e poi finito il training da utente si passa al dietro le quinte prima con MacOs e poi con XCode / Monotouch acquistando un MacBook.

Se tra qualche mese rimetto tutto su ebay il virus è contaggioso, quindi state alla larga. Se mi sentite sparare boiate o sentite puzza di fanboy riprendetemi e riportatemi sulla retta via.

Resoconto del 1° Dexter Raduno

admin — Sat, 24 Jul 2010 17:58:49 GMT

Oggi ho avuto il piacere di pranzare con Ugo e Alessandro per fare quattro chiacchiere su Dexter.

Tanto per stare leggeri Ugo ci ha deliziato portandoci in un ristorantino sul lungomare di San Benedetto a strafogarci di pesce e tra due chiacchiere su NHibernate 3, su Razor e sulla direzione da dare a Dexter il tempo è volato via.

Ringrazio Ugo per essersi sbattuto con Mauro nel procurarmi un iPad e per aver deciso di regalarmi un abbonamento MSDN Ultimate che metterò a frutto per studiare per bene le funzionalità avanzate di VS2010.

Grazie al team di Dexter e a tutto l’ecosistema della Community .Net, è un vero piacere avere a che fare con il gruppo di pazzi scatenati quali siete ;D

Prossimo raduno per la seconda metà di agosto, non mancate!

Razor

admin — Thu, 08 Jul 2010 07:14:20 GMT

Ho perso qulche ora a giocare con Razor il motore che sta dietro WebPages.

Questi i primi risultati ;D

Questione di virgole

andrea — Wed, 09 Jun 2010 21:19:58 GMT

Ho riscontrato un problema in un js nella manipolazione di un oggetto esperesso in notazione Json e ho utilizzato il debugger js integrato del browser per diagnosticarlo.

Questo è il codice che crea il problema cercando di accedere ad un oggetto non definito

<html>
<head><title>Watch test</title></head>
<body>
<script type="text/javascript">
var list = [{value:1}, {value:2},{value:3},];
for(var c = 0; c < list.length; c++){
    var elem = list[c];
    document.write(elem.value);
}
</script>
</body>
</html>

Notare la virgola prima della chisura dell’array: questo implica che il nostro array ha un elemento undefined in più, quindi il sull’ultimo elemento il js si pianta tentando di accedere ad una proprietà di un oggetto undefined.

Ecco cosa accade con i vari browser

Primo test: elemento undefined in fondo all’array

Internet Explorer 8
L’errore viene puntualmente identificato

andiamo in debug e mettiamo un watch

Il nostro array è composto da 3 elementi ma è lungo 4!

Internet Explorer 9 platform preview
Non si aggancia il debugger all’istanza, ma l’errore non si presenta se la pagina è messa in modalità “IE9 Document Mode” mentre nelle altre modalità è presente.

Firefox 3.6 beta 4 + Firebug
Firefox se ne frega bellamente, l’array è da 3: nessun errore

Chrome 5.0.375.70 beta
Anche chrome si prende la briga di considerare l’array da 3

Secondo test: elemento undefined in mezzo all’array

<html>
<head><title>Watch test</title></head>
<body>
<script type="text/javascript">
var list = [{value:1}, {value:2},,{value:3}];
for(var c = 0; c < list.length; c++){
    var elem = list[c];
    document.write(elem.value);
}
    document.write('fine');
</script>
</body>
</html>

Internet Explorer 8
Per explorer non è cambiato nulla, l’array è sempre da 4 e l’errore si presenta puntualmente.

Internet Explorer 9 platform preview
Errore sempre presente, ma è impossibile valutare il debugger.

Firefox 3.6 beta 4 + Firebug
L’array è da 4 elementi di cui uno undefined

Chrome 5.0.375.70 beta
Anche per Chrome le cose non sono cambiate.
L’errore viene visualizzato solamente con i tool di sviluppo attivi.

Conclusioni

L’unico debugger a visualizzare correttamente la lista è Firebug che mostra un bel "undefined”
Explorer8 ha un comportamento differente dagli altri browser mentre IE9 si allinea al comportamento di FireFox e Chrome
Quando possibile far generare il Json da c#

NHibernate Day

andrea — Tue, 18 May 2010 09:00:54 GMT

DotNetMarche e UgiAlt.Net hanno unito le forze per creare il primo evento dedicado ad NHibernate in Italia. Per i dettagli rimando al post di Simone ed al sito dedicato realizzato grazie all’infaticabile Claudio.

Let the fun begin!

Creare un EditorTemplate per gli enum con MVC 2

andrea — Wed, 05 May 2010 07:00:00 GMT

Intro

Nelle mie applicazioni faccio largo uso di enums (e chi non lo fa?), mi sono quindi creato una serie di helpers / providers per la gestione della UI bindata con gli enum.

In WebForms utilizzo:

IEnumDescriptionProvider: servizio che estrapola le descrizioni.
- LocalizedEnumDescriptionProvider per le descrizioni localizzate
- AttributeEnumDescriptionProvider per leggere degli attributi custom
- AutomaticCaseEnumDescriptionProvider per la conversione automatica al cambio di case (UnValore –> Un Valore)
- DefaultEnumDescriptionProvider che fa il semplice ToString()
IDropDownItemsProvider per creare le liste di valori da passare alle dropdown.
- DefaultEnumDropDownItemsProvider che ha per chiave il valore numerico dell’enum e per testo la descrizione estrapolata tramite i provider.

Visto che MVC2 è estendibile ho provato a riportare le funzionalità di base su questa piattaforma.

Questo è il model

public class Movie
{
    [Required]
    public string Title { get; set; }
    public Rating Rating { get; set; }
}

e questo l’enum

public enum Rating 
{
    None,
    Horrible,
    Bad,
    Poor,
    BelowAverage,
    Average,
    AboveAverage,
    Good,
    VeryGood,
    Superb,
    Excellent
}

Sfruttando il nuovo motore di template possiamo scrivere la form di inserimento dati come

<% using (Html.BeginForm()){%>
   <%= Html.EditorForModel() %>
   <input type="submit" value="Create" />
<%}%>

Il risultato è il seguente:

Decisamente poco user friendly.

Step 1 – gestire le descrizioni tramite attributo

MVC2 utilizza DataAnnotations e l’attributo DisplayNameAttribute per poter impostare una label custom sui controlli. Purtroppo l’attributo DisplayNameAttribute non è utilizzabile direttamente sul singolo valore dell’enum. Bypassiamo il problema creando la nostra versione e cambiando l’AttributeUsage

[AttributeUsage(AttributeTargets.Enum | AttributeTargets.Field)]
public class EnumDisplayNameAttribute : DisplayNameAttribute
{
    public EnumDisplayNameAttribute(string displayName)
        :base(displayName)
    {
    }
}

In questo modo è possibile decorare l’enum

[EnumDisplayName("** Rating")]
public enum Rating 
{
    None,
    Horrible,
    Bad,
    Poor,
    [EnumDisplayName("Below Average")]
    BelowAverage,
    Average,
    [EnumDisplayName("Above Average")]
    AboveAverage,
    Good,
    [EnumDisplayName("Very Good")]
    VeryGood,
    Superb,
    [EnumDisplayName("Just... WOW!")]
    Excellent
}

Step 2 – estendere l’enum

Abbiamo bisogno di leggere il valore degli enum e di poter creare una lista di valori da passare al controllo DropDown. Implementiamo entrambe le funzionalità come Extension Methods

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace EnumTemplates.Helpers
{
    public static class EnumExtensions
    {
        public static string GetDisplayName(this Enum enumItem)
        {
            var mi = enumItem.GetType().GetMember(enumItem.ToString()).FirstOrDefault();
            if(mi != null)
            {
                var dn = (EnumDisplayNameAttribute)(mi.GetCustomAttributes(typeof(EnumDisplayNameAttribute), false)).FirstOrDefault();
                if (dn != null)
                    return dn.DisplayName;
            }

            return enumItem.ToString();
        }

        public static IEnumerable<SelectListItem> ToSelectList(this Enum enumItem)
        {
            var enumType = enumItem.GetType();

            return (from object value in Enum.GetValues(enumType)
                    select new SelectListItem
                               {
                                   Selected = value.ToString() == enumItem.ToString(), 
                                   Text = ((Enum)value).GetDisplayName(), 
                                   Value = ((int)value).ToString()
                               }).ToList();
        }
    }
}

Step 3 – Creare un template di default per gli Enum

Nella cartella Views\Shared\EditorTemplates creiamo un nuovo usercontrol Enum.ascx

il cui sorgente è il seguente

<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl<Enum>" %>
<%@ Import Namespace="EnumTemplates.Helpers" %>
<%= Html.DropDownListFor(x => x,Model.ToSelectList()) %>

Step 4 – Abilitare il template per il nostro Enum

Piuttosto che decorare con l’attributo UIHint ogni property del nostro ViewModel (che è un approccio decisamente poco DRY) proviamo a decorare direttamente l’enum Ratings.

Anche in questo caso ci sono limitazioni sull’utilizzo dell’attributo, la soluzione la conosciamo già ;D

using System;
using System.ComponentModel.DataAnnotations;

namespace EnumTemplates.Helpers
{
    [AttributeUsage(AttributeTargets.Enum)]
    public class EnumUIHintAttribute : UIHintAttribute
    {
        public EnumUIHintAttribute(string uiHint)
            : base(uiHint)
        {
            
        }
    }
}

a questo punto possiamo definire il nostro enumerativo come

using EnumTemplates.Helpers;

namespace EnumTemplates.Models
{
    [EnumDisplayName("** Rating")]
    [EnumUIHint("Enum")]
    public enum Rating 
    {
        None,
        Horrible,
        Bad,
        Poor,
        [EnumDisplayName("Below Average")]
        BelowAverage,
        Average,
        [EnumDisplayName("Above Average")]
        AboveAverage,
        Good,
        [EnumDisplayName("Very Good")]
        VeryGood,
        Superb,
        [EnumDisplayName("Just... WOW!")]
        Excellent
    }
}

Step 5 – Up & Running

Step fondamentale…. F5 e test nel browser..

e se diamo un’occhiata al sorgente HTML troviamo

decisamente meglio.

Sorgenti

Visual Studio 2010 Community Launch Tour - Perugia

andrea — Sun, 02 May 2010 12:44:37 GMT

Giovedì scorso ho avuto l’onore di presentare MVC2 al Community Tour di lancio di Visual Studio 2010 in quel di Perugia: raccolgo in questo post qualche considerazione in merito ed i link al materiale.

Prima di tutto ringrazio i partecipanti che restando ben oltre il tempo previsto hanno seguito con attenzione la sessione si MVC2 che è stata rivista “on the fly” in base ai feedback.

La sessione era nata per mostrare le novità di MVC2 rispetto alla versione precedente ma già alla prima domanda ai partecipanti ha cambiato direzione.

Prima domanda: “Chi conosce MVC?”… e nessun braccio alzato.

Seconda domanda: “Preferite una sessione slide o codice?”… risposta scontata.. Codice

In 30 secondi polverizzato il lavoro fatto per preparare la mia sessione, non male come inizio.

Alla fine è andata bene, l’attenzione è stata alta fino alla fine (oltre le 19.00) e i primi feedback sono sembrati più che buoni.

Probabilmente manca un evento hands-on (ipotesi di cui discuto da tempo con i ragazzi della community) per dare una bella spinta nella direzione giusta e far toccare con mano i benefici di MVC. Magari dopo l’estate si organizza qualcosa… stay tuned!

Asp.Net MVC 2 :: VS 2010 Community Tour

View more presentations from andreabalducci.

Codice e slide scaricabili da http://ienumerable.codeplex.com/SourceControl/changeset/changes/99c1cc2736db

Usertypes per database legacy

andrea — Wed, 21 Apr 2010 08:28:02 GMT

Mi trovo a lavorare su un database legacy in cui non vengono usati i null sulle reference esterne. Questo significa che la chiave stringa null è pari a stringa vuota e gli interi (16 e 32 bit) sono pari a zero.

Per mappare questa casistica su NHibernate ho creato tre usertypes che fanno automaticamente la conversione in lettura / scrittura trasformando i valori “Zero” in null e viceversa.

String

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using NHibernate;
using NHibernate.SqlTypes;
using NHibernate.UserTypes;

namespace Prxm.Framework.Data.NHibernate.UserTypes
{
    public class EmptyStringAsNullType : IUserType, IEnhancedUserType
    {
        #region IUserType Members
        public bool IsMutable
        {
            get { return false; }
        }

        public Type ReturnedType
        {
            get { return typeof(string); }
        }

        public SqlType[] SqlTypes
        {
            get { return new[] { NHibernateUtil.String.SqlType }; }
        }

        public object NullSafeGet(IDataReader rs, string[] names, object owner)
        {
            var obj = NHibernateUtil.String.NullSafeGet(rs, names[0]);

            if (obj == null)
            {
                return null;
            }

            var value = (string)obj;
            if (String.IsNullOrEmpty(value))
            {
                return null;
            }

            return value.Trim();
        }

        public void NullSafeSet(IDbCommand cmd, object value, int index)
        {
            if (value == null)
            {
                ((IDataParameter)cmd.Parameters[index]).Value = String.Empty;
            }
            else
            {
                ((IDataParameter)cmd.Parameters[index]).Value = ((string)value).Trim();
            }
        }

        public object DeepCopy(object value)
        {
            return value;
        }

        public object Replace(object original, object target, object owner)
        {
            return original;
        }

        public object Assemble(object cached, object owner)
        {
            return cached;
        }

        public object Disassemble(object value)
        {
            return value;
        }

        public new bool Equals(object x, object y)
        {
            if (ReferenceEquals(x, y))
            {
                return true;
            }

            if (x == null || y == null)
            {
                return false;
            }

            return x.Equals(y);
        }

        public int GetHashCode(object x)
        {
            return x == null ? typeof(string).GetHashCode() + 473 : x.GetHashCode();
        }
        #endregion

        public object FromXMLString(string xml)
        {
            return xml;
        }

        public string ObjectToSQLString(object value)
        {
            return (string) value ?? string.Empty;
        }

        public string ToXMLString(object value)
        {
            return (string)value ?? string.Empty;
        }
    }
}

Int32

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using NHibernate;
using NHibernate.SqlTypes;
using NHibernate.UserTypes;

namespace Prxm.Framework.Data.NHibernate.UserTypes
{
    public class Int32ReferenceType : IEnhancedUserType
    {
        #region Implementation of IUserType

        /// <summary>
        /// Compare two instances of the class mapped by this type for persistent "equality"
        ///             ie. equality of persistent state
        /// </summary>
        /// <param name="x"/><param name="y"/>
        /// <returns/>
        public bool Equals(object x, object y)
        {
            if (ReferenceEquals(x, y))
            {
                return true;
            }

            if (x == null || y == null)
            {
                return false;
            }

            return x.Equals(y);
        }

        /// <summary>
        /// Get a hashcode for the instance, consistent with persistence "equality"
        /// </summary>
        public int GetHashCode(object x)
        {
            return x == null ? typeof(string).GetHashCode() + 473 : x.GetHashCode();
        }

        /// <summary>
        /// Retrieve an instance of the mapped class from a JDBC resultset.
        ///             Implementors should handle possibility of null values.
        /// </summary>
        /// <param name="rs">a IDataReader</param><param name="names">column names</param><param name="owner">the containing entity</param>
        /// <returns/>
        /// <exception cref="T:NHibernate.HibernateException">HibernateException</exception>
        public object NullSafeGet(IDataReader rs, string[] names, object owner)
        {
            var obj = NHibernateUtil.Int32.NullSafeGet(rs, names[0]);

            if (obj == null)
            {
                return null;
            }

            var value = (int)obj;
            if (value == 0)
            {
                return null;
            }

            return value;
        }

        /// <summary>
        /// Write an instance of the mapped class to a prepared statement.
        ///             Implementors should handle possibility of null values.
        ///             A multi-column type should be written to parameters starting from index.
        /// </summary>
        /// <param name="cmd">a IDbCommand</param><param name="value">the object to write</param><param name="index">command parameter index</param><exception cref="T:NHibernate.HibernateException">HibernateException</exception>
        public void NullSafeSet(IDbCommand cmd, object value, int index)
        {
            if (value == null)
            {
                ((IDataParameter)cmd.Parameters[index]).Value = 0;
            }
            else
            {
                ((IDataParameter)cmd.Parameters[index]).Value = (int)value;
            }
        }

        /// <summary>
        /// Return a deep copy of the persistent state, stopping at entities and at collections.
        /// </summary>
        /// <param name="value">generally a collection element or entity field</param>
        /// <returns>
        /// a copy
        /// </returns>
        public object DeepCopy(object value)
        {
            return value;
        }

        /// <summary>
        /// During merge, replace the existing (<paramref name="target"/>) value in the entity
        ///             we are merging to with a new (<paramref name="original"/>) value from the detached
        ///             entity we are merging. For immutable objects, or null values, it is safe to simply
        ///             return the first parameter. For mutable objects, it is safe to return a copy of the
        ///             first parameter. For objects with component values, it might make sense to
        ///             recursively replace component values.
        /// </summary>
        /// <param name="original">the value from the detached entity being merged</param><param name="target">the value in the managed entity</param><param name="owner">the managed entity</param>
        /// <returns>
        /// the value to be merged
        /// </returns>
        public object Replace(object original, object target, object owner)
        {
            return original;
        }

        /// <summary>
        /// Reconstruct an object from the cacheable representation. At the very least this
        ///             method should perform a deep copy if the type is mutable. (optional operation)
        /// </summary>
        /// <param name="cached">the object to be cached</param><param name="owner">the owner of the cached object</param>
        /// <returns>
        /// a reconstructed object from the cachable representation
        /// </returns>
        public object Assemble(object cached, object owner)
        {
            return cached;
        }

        /// <summary>
        /// Transform the object into its cacheable representation. At the very least this
        ///             method should perform a deep copy if the type is mutable. That may not be enough
        ///             for some implementations, however; for example, associations must be cached as
        ///             identifier values. (optional operation)
        /// </summary>
        /// <param name="value">the object to be cached</param>
        /// <returns>
        /// a cacheable representation of the object
        /// </returns>
        public object Disassemble(object value)
        {
            return value;
        }

        /// <summary>
        /// The SQL types for the columns mapped by this type. 
        /// </summary>
        public SqlType[] SqlTypes
        {
            get { return new[] { NHibernateUtil.Int32.SqlType }; }
        }

        /// <summary>
        /// The type returned by <c>NullSafeGet()</c>
        /// </summary>
        public Type ReturnedType
        {
            get { return typeof(int); }
        }

        /// <summary>
        /// Are objects of this type mutable?
        /// </summary>
        public bool IsMutable
        {
            get { return false; }
        }

        #endregion

        #region Implementation of IEnhancedUserType

        /// <summary>
        /// Parse a string representation of this value, as it appears
        ///             in an XML document.
        /// </summary>
        public object FromXMLString(string xml)
        {
            return xml;
        }

        /// <summary>
        /// Return an SQL literal representation of the value
        /// </summary>
        public string ObjectToSQLString(object value)
        {
            return value != null ? value.ToString() : "0";
        }

        /// <summary>
        /// Return a string representation of this value, as it
        ///             should appear in an XML document
        /// </summary>
        public string ToXMLString(object value)
        {
            return value != null ? value.ToString() : "0";
        }

        #endregion
    }
}

Int16

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using NHibernate;
using NHibernate.SqlTypes;
using NHibernate.UserTypes;

namespace Prxm.Framework.Data.NHibernate.UserTypes
{
    public class Int16ReferenceType : IEnhancedUserType
    {
        #region Implementation of IUserType

        /// <summary>
        /// Compare two instances of the class mapped by this type for persistent "equality"
        ///             ie. equality of persistent state
        /// </summary>
        /// <param name="x"/><param name="y"/>
        /// <returns/>
        public bool Equals(object x, object y)
        {
            if (ReferenceEquals(x, y))
            {
                return true;
            }

            if (x == null || y == null)
            {
                return false;
            }

            return x.Equals(y);
        }

        /// <summary>
        /// Get a hashcode for the instance, consistent with persistence "equality"
        /// </summary>
        public int GetHashCode(object x)
        {
            return x == null ? typeof(string).GetHashCode() + 473 : x.GetHashCode();
        }

        /// <summary>
        /// Retrieve an instance of the mapped class from a JDBC resultset.
        ///             Implementors should handle possibility of null values.
        /// </summary>
        /// <param name="rs">a IDataReader</param><param name="names">column names</param><param name="owner">the containing entity</param>
        /// <returns/>
        /// <exception cref="T:NHibernate.HibernateException">HibernateException</exception>
        public object NullSafeGet(IDataReader rs, string[] names, object owner)
        {
            var obj = NHibernateUtil.Int16.NullSafeGet(rs, names[0]);

            if (obj == null)
            {
                return null;
            }

            var value = (Int16)obj;
            if (value == 0)
            {
                return null;
            }

            return value;
        }

        /// <summary>
        /// Write an instance of the mapped class to a prepared statement.
        ///             Implementors should handle possibility of null values.
        ///             A multi-column type should be written to parameters starting from index.
        /// </summary>
        /// <param name="cmd">a IDbCommand</param><param name="value">the object to write</param><param name="index">command parameter index</param><exception cref="T:NHibernate.HibernateException">HibernateException</exception>
        public void NullSafeSet(IDbCommand cmd, object value, int index)
        {
            if (value == null)
            {
                ((IDataParameter)cmd.Parameters[index]).Value = (Int16)0;
            }
            else
            {
                ((IDataParameter)cmd.Parameters[index]).Value = (Int16)value;
            }
        }

        /// <summary>
        /// Return a deep copy of the persistent state, stopping at entities and at collections.
        /// </summary>
        /// <param name="value">generally a collection element or entity field</param>
        /// <returns>
        /// a copy
        /// </returns>
        public object DeepCopy(object value)
        {
            return value;
        }

        /// <summary>
        /// During merge, replace the existing (<paramref name="target"/>) value in the entity
        ///             we are merging to with a new (<paramref name="original"/>) value from the detached
        ///             entity we are merging. For immutable objects, or null values, it is safe to simply
        ///             return the first parameter. For mutable objects, it is safe to return a copy of the
        ///             first parameter. For objects with component values, it might make sense to
        ///             recursively replace component values.
        /// </summary>
        /// <param name="original">the value from the detached entity being merged</param><param name="target">the value in the managed entity</param><param name="owner">the managed entity</param>
        /// <returns>
        /// the value to be merged
        /// </returns>
        public object Replace(object original, object target, object owner)
        {
            return original;
        }

        /// <summary>
        /// Reconstruct an object from the cacheable representation. At the very least this
        ///             method should perform a deep copy if the type is mutable. (optional operation)
        /// </summary>
        /// <param name="cached">the object to be cached</param><param name="owner">the owner of the cached object</param>
        /// <returns>
        /// a reconstructed object from the cachable representation
        /// </returns>
        public object Assemble(object cached, object owner)
        {
            return cached;
        }

        /// <summary>
        /// Transform the object into its cacheable representation. At the very least this
        ///             method should perform a deep copy if the type is mutable. That may not be enough
        ///             for some implementations, however; for example, associations must be cached as
        ///             identifier values. (optional operation)
        /// </summary>
        /// <param name="value">the object to be cached</param>
        /// <returns>
        /// a cacheable representation of the object
        /// </returns>
        public object Disassemble(object value)
        {
            return value;
        }

        /// <summary>
        /// The SQL types for the columns mapped by this type. 
        /// </summary>
        public SqlType[] SqlTypes
        {
            get { return new[] { NHibernateUtil.Int16.SqlType }; }
        }

        /// <summary>
        /// The type returned by <c>NullSafeGet()</c>
        /// </summary>
        public Type ReturnedType
        {
            get { return typeof(Int16); }
        }

        /// <summary>
        /// Are objects of this type mutable?
        /// </summary>
        public bool IsMutable
        {
            get { return false; }
        }

        #endregion

        #region Implementation of IEnhancedUserType

        /// <summary>
        /// Parse a string representation of this value, as it appears
        ///             in an XML document.
        /// </summary>
        public object FromXMLString(string xml)
        {
            return xml;
        }

        /// <summary>
        /// Return an SQL literal representation of the value
        /// </summary>
        public string ObjectToSQLString(object value)
        {
            return value != null ? value.ToString() : "0";
        }

        /// <summary>
        /// Return a string representation of this value, as it
        ///             should appear in an XML document
        /// </summary>
        public string ToXMLString(object value)
        {
            return value != null ? value.ToString() : "0";
        }

        #endregion
    }
}

IEnumerable - Il blog personale di Andrea Balducci

Libero professionista vs Dipendente

Sviluppare per Windows Mobile su Windows7

Deploy di Orchard su Azure

La strana storia di Quartz, Castle ed NHibernateFacility nel mondo di Lucilla

Convertire in automatico il testo con MVC2

Tip: Esecuzione veloce di Unit Test con Resharper

Visual Studio 2010 e ReadyBoost

La percezione dei prodotti

Resoconto del 1° Dexter Raduno

Related Content

Razor

Related Content

Questione di virgole

NHibernate Day

Related Content

Creare un EditorTemplate per gli enum con MVC 2

Related Content

Visual Studio 2010 Community Launch Tour - Perugia

Related Content

Usertypes per database legacy

Related Content