NHibernate

NHibernate 1.2.1GA

Simone Belia — Tue, 27 Nov 2007 19:16:04 GMT

Ieri è stata rilasciata la versione 1.2.1GA e la potete trovare a questo indirizzo:

http://sourceforge.net/project/showfiles.php?group_id=73818&package_id=73969

Di aggiunte non ha, hanno solo corretto alcuni bug, ma la bella notizia è che stavano aspettando di rilasciare questa release per iniziare a dedicarsi pesantemente alla versione 2.0.....e li si che ci sarà da divertirsi.

A questo indirizzo potete trovare quelle che saranno le nuove funzionalità...e non sono poche.
Leggete anche i feedback ce n'è uno di Fabio Maulo che integra il post.

Recuperare solo i valori essenziali con Nhibernate

Simone Belia — Fri, 16 Nov 2007 19:57:26 GMT

L'infrastruttura di NHibernate ci permette di recuperare con pochi sforzi le informazioni che stanno nel DB sottoforma di nostre classi opportunamente istruite.

Bene....e che c'è di nuovo?
Nulla....ma ipotizziamo questo:

Ho una classe Customer che contiene 40 proprietà (non associazioni) che la descrivono.
Ora voglio che in un menu a tendina della mia applicazione vengano inseriti tutti i Customer così da farne scegliere uno all'utente.

In questo scenario quello che mi serve è solo l'ID del customer ed il suo nome....allora perchè caricarsi tutti quanti i suoi dati?

Negli ultimi progetti che ho sviluppato con NHibernate ho cercato di trovare una metodologia per venire incontro a questa comune problematica in maniera "comoda" e "tipizzata"....e spero che quello che ho fatto possa rilevarsi utile anche per voi!!! :-)

Per prima cosa mi sono costruito una classe generica che mi permetta di descrivere i miei valori:

public class NameValueDTO<Tv, Tn>
{
   private Tn _name;
   private Tv _value; 

   public Tn Name 
   { 
      get { return _name; } 
   } 
        
   public Tv Value 
   { 
      get { return _value; } 
   }

   public NameValueDTO(Tv value, Tn name)
   {
      _name = name;
      _value = value;
   }
}

Successivamente mi sono costruito un metodo generico rappresentante la classe per la quale voglio estrapolare i valori (nel nostro caso Customer) ed al quale passerò il nome della proprietà dell'oggetto che vorrò visualizzare.

public IList<NameValueDTO<int,string>> GetNameValue<T>(string propName)
{
   ICriteria criteria = _session.CreateCriteria(typeof(T));
   ProjectionList pl = Projections.ProjectionList();
                        
   pl.Add(Projections.Id());
   pl.Add(Projections.Property(propName));

   criteria.SetProjection(pl);
                        
   criteria.SetResultTransformer(new NHibernate.Transform.AliasToBeanConstructorResultTransformer(
               typeof(NameValueDTO<int,string>).GetConstructors()[0]));

   return criteria.List<NameValueDTO<int, string>>();
}

Esaminiamo il codice.
La prima istruzione crea un oggeto Criteria basandosi sul tipo della classe che ho passatto come parametro del generic.
Successviamente creo una ProjectionList che mi servirà per incapsulare i campi che desidero "aggregare" (anche se non è la parola giusta in questo esempio....:-)).

L'istruzione successiva è la più interessante.
SetResultTransformer dice ad NH di trasformare (AliasToBeanConstructorResultTransformer) i valori di ritorno dalla query istanziare nel tipo di oggetto che gli ho specificato (typeof(NameValueDTO<int,string>)) utilizzando il primo costruttore GetConstructors()[0];

A questo punto il gioco è fatto....richiamando il metodo GetNameValue mi verrà ritornata la mia bella collezione con solo i campi richiesti.

NHibernate complex queries

Simone Belia — Wed, 10 Oct 2007 19:04:13 GMT

Poco tempo fa (e tutt'ora) mi sono trovato di fronte ad un'applicazione sviluppata con NHibernate che richiedeva moltissimi filtri per fare delle ricerche molto complesse.

Cercando un pò in giro sono arrivato a leggere questo articolo di Ayende che esponeva una soluzione molto elegante e funzionale per effettuare ricerche complesse con NHibernate.....ed a pensarci bene è un buon pattern anche senza l'uso di NH.

L'articolo lo trovate qui: http://www.ayende.com/Blog/archive/2006/12/07/7055.aspx

Il concetto di base è quello di crearsi un oggetto Finder che non fa altro che incapsulare tutti i dati che devono essere cercati. Questo oggetto viene poi passato ad un metodo che altro non fa che valutare le informazioni presenti nell'oggetto per poi costruire il criteria o l'hql necessario.

Tornando al mio applicativo, ho notato che c'erano dei casi in cui la semplice impostazione di una Property non mi bastava poichè dovevo legarci anche come quell'informazione doveva essere trattata.

Per esempio una Property cognome doveva essere corredata anche dall'informazione di dove cercare, ossia se il valore doveva essere *contenuto*, oppure *iniziare per* o *finire per*. Altro esempio erano i valori range, come controllare se alcune informazioni erano comprese tra la data e la data.

Proprio per questo ho esteso la soluzione di Ayende creandomi un paio di classi chiamate SearchableField e SearchableRange.

L'implementazione delle classi è:

//SEARCHABLEFIELD
public class SearchableField<T>
    {
        private T _search;
        private FinderOperator _expression = FinderOperator.Equals;

        public FinderOperator Expression
        {
            get { return _expression; }
            set { _expression = value; }
        }

        public T Search
        {
            get { return _search; }
            set { _search = value; }
        }

        public SearchableField(T search, FinderOperator expression)
        {
            this._search = search;
            this._expression = expression;
        }

    }

//SEARCHABLERANGE
public class SearchableRange<T>
    {
        private SearchableField<T> _from;
        private SearchableField<T> _to;

        public SearchableField<T> From
        {
            get { return _from; }
            set { _from = value; }
        }

        public SearchableField<T> To
        {
            get { return _to; }
            set { _to = value; }
        }

        public SearchableRange(SearchableField<T> from, SearchableField<T> to)
        {
            this._from = from;
            this._to = to;
        }
    }

Logicamente le due classi utilizzano i Generics così da poter essere riutilizzate a seconda del tipo da implementare.

Come noterete c'è anche un parametro di tipo FinderOperator che identifica quale comportamento di ricerca implementare.

public enum FinderOperator
    {
        Equals = 0,
        NotEquals = 1,
        Contains = 2,
        GreaterThan = 3,
        LessThan = 4,
        GreaterOrEqualThan = 5,
        LessOrEqualThan = 6,
        In = 7,
        NotIn = 8
    }

A questo punto l'unica cosa che era rimasta da fare è crearmi la mia classe Finder di cui qua riporto un abstract:

public class CustomerFinder
    {

        #region Social Field

        private SearchableField<string> _companyName = null;
        private int? _customerId = null;
        private SearchableRange<int> _age = null;

        public SearchableRange<int> Age
        {
            get { return _age; }
            set { _age = value; }
        }

        public SearchableField<string> CompanyName
        {
            get { return _companyName; }
            set { _companyName = value; }
        }

        public int? CustomerId
        {
            get { return _customerId; }
            set { _customerId = value; }
        }

        #endregion

        #region Geographic Fields

        private SearchableField<List<Country>> _localities = null;

        public SearchableField<List<Country>> Localities
        {
            get { return _localities; }
            set { _localities = value; }
        }

        #endregion

        #region Economic Fields

        private SearchableRange<DateTime?> _purchasedDates;
        private SearchableRange<decimal> _amount;

        public SearchableRange<DateTime?> PurchasedDates
        {
            get { return _purchasedDates; }
            set { _purchasedDates = value; }
        }

        public SearchableRange<decimal> Amount
        {
            get { return _amount; }
            set { _amount = value; }
        }

        #endregion

    }

ed il suo utilizzo è stato una cosa del genere:

CustomerFinder cf = new CustomerFinder();

cf.CompanyName = new SearchableField<string>("Gates",FinderOperator.Contains);
cf.Age = new SearchableField<int>(25,FinderOperator.GreaterOrEqualThan);

CustomerPersistence persistence = new CustomerPersistence();
IList<Customer> list = persistence.Find(cf);

Logicamente ci sarebbe ancora tanto da fare.....ma se qualcuno ha tempo potrebbe estendere ancora di più, no?