28/06/11

Linq estrarre tutti i figli da una collezione di oggetti

Supponiamo di avere un oggetto Utente ed un oggetto Gruppo

public class Utente
  {
    public string Nome { get; set; }
    public IList<Gruppo> Gruppi { get; set; }
  }

  public class Gruppo
  {
    public string Descrizione { get; set; }
  }


Abbiamo un collezione di oggetti Utente, ciascuno dei quali ha a sua volta una collezione di gruppi

IList<Utente> list = new List<Utente>
                             {
                               new Utente()
                                 {
                                   Gruppi = new List<Gruppo>()
                                              {
                                                new Gruppo(){Descrizione = "GRUPPO1"},
                                                new Gruppo(){Descrizione = "GRUPPO2"},
                                              }
                                 },
                                                                new Utente()
                                 {
                                   Gruppi = new List<Gruppo>()
                                              {
                                                new Gruppo(){Descrizione = "GRUPPO3"},
                                                new Gruppo(){Descrizione = "GRUPPO4"},
                                              }
                                 }

                             };


Ora vogliamo estrarre tutti i gruppi di tutti gli utenti, ma se utilizziamo la Select di Linq otterremmo un IEnumerable di liste di oggetti Gruppo:

IEnumerable<IList<Gruppo>> gruppi = list.Select(x=>x.Gruppi);

Noi invece vogliamo semplicemente una lista di oggetti gruppo e quindi possiamo scrivere:
IEnumerable<Gruppo> gruppiList = list.SelectMany(x => x.Gruppi);

26/06/11

Utilizzare Windsor IOC container con l'autoregistration

Castle Windsor è una libreria che pemette di iniettare automaticamente le dipendenze all'interno di una nostra classe (Dipendency Injection).

Questo significa che se abbiamo una classe con un costruttore che accetta come parametro delle interfacce, sostanzialmente non dovremo essere noi a fare il "new" della classe che implementa quella interfaccia, ma verrà fatto in automatico dalla libreria.

Questo è un esempio di una classe che ha nel costruttore una interfaccia di nome IRepository

public class SendMailTask : ISendMailTask
    {
        private IRepository2 _repository2;

        public SendMailTask(IRepository2 repository2)
        {
            _repository2 = repository2;
        }
    }

Normalmente per instanziare la nostra classe SendMailTask dovremmo scrivere:

SendMailTask sendMailTask = new SendMailTask(new Repository2());


Utilizzando invece Windsor, potremo scrivere:


var sendMailTask = ServiceLocatorInitializer.Container.Resolve();

Come avrete notato non abbiamo passato noi a parametro l'instanza della classe richiesta, perchè viene fatto in automatico.

Risulta molto utile quando abbiamo più parametri nel costruttore, ma soprattutto ci facilita la possibilità di testare il codice attraverso gli Unit Test.


Come funziona

Come prima cosa effettuiaamo il download di Windsor Castle dal sito www.castleproject.org

Poi referenziamo nel nostro progetto le librerie CastleCore,CastleMicrokernel e CastleWindsor

A questo punto dobbiamo registrare le dipendenze in modo che il programma sappia in automatico quale componente (o classe)
è legato ad una determinata interfaccia
e in questo modo sappia quale instanza deve creare a runtime e iniettare nel costruttore della classe.

Possiamo utilizzare un file di configurazione che non spiegheremo in questo post e nel quale registriamo le dipendenze.




    
        
        

        

        

        

    





Oppure possiamo utilizzare una nuova caratteristica di Windsor che si chiama AutoRegistration e permette
in automatico di registrare le dipendenze di uno o più assembly.

Ecco un esempio completo:

_container = new WindsorContainer();


            _container.Register(
                        AllTypes.Pick()
                        .FromAssemblyNamed(Assembly.GetExecutingAssembly().FullName)
                        .WithService.FirstInterface());


Ecco fatto, in questo modo vengono registrate tutte le dipendenze interfaccia/classe dell'assembly corrente.
Possiamo anche decidere di aggiungere altre dipendenze manualmente:


container.AddComponent("entityDuplicateChecker",
                typeof(IEntityDuplicateChecker), typeof(EntityDuplicateChecker));

Ora possiamo instanziare le nostre classi in questo modo:
var sendMailTask = ServiceLocatorInitializer.Container.Resolve();


Se abbiamo la necessità di utilizzare Windsor in varie classi, non dobbiamo instanziarlo ogni volta ma semplicemente
faremo una classe di helper usando il pattern Singleton; la prima volta chiameremo il metodo Init, le volte successive essendo una classe statica
potremo semplicemente utilizzare la proprietà pubblica "Container"

public class ServiceLocatorInitializer
    {
        private static IWindsorContainer _container;

        public static IWindsorContainer Container
        {
            get { return _container; }
        }

        public static void Init()
        {
            _container = new WindsorContainer();

            ComponentRegistrar.AddComponentsTo(_container);
            _container.Register(
                        AllTypes.Pick()
                        .FromAssemblyNamed(Assembly.GetExecutingAssembly().FullName)
                        .WithService.FirstInterface());
         
        }
    }

Concatenare una proprietà di una lista di oggetti con Linq

Supponiamo di avere una lista di oggetti e vorremmo estrarre dalla lista una proprietà e concatenarla alla successiva, magari aggiungendo un separatore come il punto e virgola.

Con Linq questa operazione è estramente veloce, basta utilizzare l'extension method denominato Aggregate.
Esempio:

public class Foo

    {

        public string Proprieta1 { get; set; }

        public string Proprieta2 { get; set; }

        public string Proprieta3 { get; set; }

    }


Popoliamo la lista:
IList list = new List()
                {
                    new Foo() {Proprieta1 = "a1",Proprieta2 = "b1",Proprieta3 = "c1"},
                    new Foo() {Proprieta1 = "a2",Proprieta2 = "b2",Proprieta3 = "c2"},
                    new Foo() {Proprieta1 = "a3",Proprieta2 = "b3",Proprieta3 = "c3"}

                };




Ora testiamo il risultato:
var proprieta1Concatenata = list.Select(x => x.Proprieta1).Aggregate((x, y) => x + ";" + y);

Assert.AreEqual("a1;a2;a3",proprieta1Concatenata);



23/06/11

Realizzare delle Faq per il vostro sito con JQuery

Oggi vediamo un esempio di come di come realizzare una pagina di Faq (Frequently Asked Questions) che possa aiutare i visitatori del vostro a capirne meglio le funzionalità.

Faremo in modo che ci siano dei link contenenti la domanda, mentre le risposte saranno non visibili; quando il visitatore cliccherà su uno di questi link, allora si visualizzerà la risposta relativa a link cliccato.
Allo stesso tempo verrà nascosta la descrizione del link dove il visitatore aveva precendentemente cliccato.

Iniziamo quindi a referenziare la libreria di Jquery:



Ora creiamo una lista di elementi, ogni elemento sarà composto da un link e da una descrizione:


Ora inseriamo il codice jquery che serve per gestire i link:



Ora vediamo la situazione iniziale della pagina:





Ora clicco il primo link:


Ora clicco il secondo link (notare la descrizione del primo link che viene nascosta):

 
Design by Free WordPress Themes | Bloggerized by Lasantha - Premium Blogger Themes | Grants For Single Moms