sabato 20 novembre 2010

Software gratis

I software gratis che possono semplificare la vita di un analista programmatore sono molti: software per la gestione di contenuti web detti anche CMS, software per la gestione delle relazioni con i clienti detti anche CRM, programmi che implementano ottimi DBMS e la lista potrebbe continuare ancora per molto.
  1. Joomla
  2. Sugar CRM
  3. MySql
  4. Eclipse 
  5. ...
Spesso questi software gratis hanno pure il grande vantaggio di essere Open Source anche se esistono molti casi in cui questo non è vero (Open source significa letteralmente codice sorgente aperto non software gratuito).
I vantaggi di un corretto utilizzo di questo genere di programmi sono enormi in termini di tempo e sicurezza delle applicazioni. Grazie alle comunità che nascono attorno a questi prodotti siamo certi di avere continui aggiornamenti e correzioni. Spesso viene data la possibilità di estendere facilmente le applicazioni utilizzando classi e metodi propri del framework rendendo il codice robusto e ben strutturato aumentando notevolmente la manutenibilità e la estendibilità delle applicazioni.
Quando un problema informatico è stato affrontato e risolto da altri non è furbo ricominciare daccapo.
venerdì 5 novembre 2010

Cruscotto aziendale e TaleteWeb

Il Cruscotto aziendale è uno strumento informatico che consente all'imprenditore di monitorare i principali obiettivi pianificati per la propria azienda: TaleteWeb offre un potente Cruscotto aziendale in cui confluiscono tutti gli indicatori elaborati dall'applicazione per offrire una efficace visione d'insieme dell'impresa.
TaleteWeb è un programma sviluppato in ASP.NET finalizzato alla gestione integrata dei seguenti, principali, processi direzionali, organizzativi e gestionali, delle imprese pubbliche e private (in particolare delle P.M.I. di diversi settori):
  • Budget, Organizzazione, Formazione
  • Qualità, Privacy
  • Ambiente, Salute e Sicurezza
  • Sicurezza Alimentare
Ecco un esempio dei grafici presenti nel Cruscotto aziendale in TaleteWeb

Cruscotto aziendale TaleteWeb
giovedì 28 ottobre 2010

Facebook SDK C#

Facebook ha rilasciato un SDK per C#: il progetto è ospitato su github e funziona sia con ASP.NET che con le applicazioni desktop. Tra le nuove feature abbiamo OAuth 2.0  per l'autenticazione e il supporto a Open Graph su .NET. L'SDK è ancora considerato come in fase alpha.
sabato 16 ottobre 2010

Abstract Factory Design Pattern C#

Il pattern Abstract Factory fa parte dei cosiddetti Creational patterns cioè di quel genere di pattern che si occupa di istanziare (creare) oggetti.
La sua peculiarità è quella di fornire una interfaccia per creare famiglie di oggetti connessi o dipendenti tra loro, in modo che non ci sia necessità da parte dei client di specificare i nomi delle classi concrete all'interno del proprio codice.
Vediamo il diagramma UML:

Abstract Factory Design Pattern C#

Di seguito riportiamo la sua realizzazione in C#

// Abstract Factory pattern -- Structural example
using System;

namespace DoFactory.GangOfFour.Abstract.Structural
{
  /// <summary>
  /// MainApp startup class for Structural
  /// Abstract Factory Design Pattern.
  /// </summary>
  class MainApp
  {
    /// <summary>
    /// Entry point into console application.
    /// </summary>
    public static void Main()
    {
      // Abstract factory #1
      AbstractFactory factory1 = new ConcreteFactory1();
      Client client1 = new Client(factory1);
      client1.Run();

      // Abstract factory #2
      AbstractFactory factory2 = new ConcreteFactory2();
      Client client2 = new Client(factory2);
      client2.Run();

      // Wait for user input
      Console.ReadKey();
    }
  }

  /// <summary>
  /// The 'AbstractFactory' abstract class
  /// </summary>
  abstract class AbstractFactory
  {
    public abstract AbstractProductA CreateProductA();
    public abstract AbstractProductB CreateProductB();
  }


  /// <summary>
  /// The 'ConcreteFactory1' class
  /// </summary>
  class ConcreteFactory1 : AbstractFactory
  {
    public override AbstractProductA CreateProductA()
    {
      return new ProductA1();
    }
    public override AbstractProductB CreateProductB()
    {
      return new ProductB1();
    }
  }

  /// <summary>
  /// The 'ConcreteFactory2' class
  /// </summary>
  class ConcreteFactory2 : AbstractFactory
  {
    public override AbstractProductA CreateProductA()
    {
      return new ProductA2();
    }
    public override AbstractProductB CreateProductB()
    {
      return new ProductB2();
    }
  }

  /// <summary>
  /// The 'AbstractProductA' abstract class
  /// </summary>
  abstract class AbstractProductA
  {
  }

  /// <summary>
  /// The 'AbstractProductB' abstract class
  /// </summary>
  abstract class AbstractProductB
  {
    public abstract void Interact(AbstractProductA a);
  }


  /// <summary>
  /// The 'ProductA1' class
  /// </summary>
  class ProductA1 : AbstractProductA
  {
  }

  /// <summary>
  /// The 'ProductB1' class
  /// </summary>
  class ProductB1 : AbstractProductB
  {
    public override void Interact(AbstractProductA a)
    {
      Console.WriteLine(this.GetType().Name +
        " interacts with " + a.GetType().Name);
    }
  }

  /// <summary>
  /// The 'ProductA2' class
  /// </summary>
  class ProductA2 : AbstractProductA
  {
  }

  /// <summary>
  /// The 'ProductB2' class
  /// </summary>
  class ProductB2 : AbstractProductB
  {
    public override void Interact(AbstractProductA a)
    {
      Console.WriteLine(this.GetType().Name +
        " interacts with " + a.GetType().Name);
    }
  }

  /// <summary>
  /// The 'Client' class. Interaction environment for the products.
  /// </summary>
  class Client
  {
    private AbstractProductA _abstractProductA;
    private AbstractProductB _abstractProductB;

    // Constructor
    public Client(AbstractFactory factory)
    {
      _abstractProductB = factory.CreateProductB();
      _abstractProductA = factory.CreateProductA();
    }

    public void Run()
    {
      _abstractProductB.Interact(_abstractProductA);
    }
  }
}

L'Output prodotto da questo semplice programma sarà:

ProductB1 interacts with ProductA1
ProductB2 interacts with ProductA2
giovedì 14 ottobre 2010

C# params keyword

params indica un numero variabile di parametri in un metodo.


La parola chiave params introduce nella programmazione in ambiente .NET la possibilità di avere dei metodi con un numero di parametri dinamico.

public static void UseParams(params int[] list)
{
    for (int i = 0; i < list.Length; i++)
        Console.Write(list[i] + " ");
    Console.WriteLine();
}

Questo metodo può essere chiamato in questo modo:
UseParams(1, 2, 3, 4);

Se vogliamo specificare una quantità di elementi diversi basta separarli dalla virgola; sarà il compilatore a istanziare un array e a impostare gli elementi con i valori dati nel metodo.
venerdì 8 ottobre 2010

Singleton Design Pattern C#

Il Singleton è uno dei pattern fondamentali della programmazione ad oggetti e viene utilizzato quando si ha l'esigenza di creare una sola istanza per una determinata classe.
In pratica se vogliamo che nella nostra applicazione ci sia un solo oggetto di un determinato tipo la "Gang of four" consiglia di utilizzare il singleton come accesso "globale" a questa unica istanza.
I requisiti per implementare questo pattern sono i seguenti:
  1. Un singolo costruttore privato e senza parametri. Questo evita che altre classi possano istanziare nuovi oggetti del tipo in questione (sarebbe una violazione del pattern) 
  2.  La presenza di una variabile statica (variabile di classe) che mantiene il riferimento all'unica istanza possibile
  3. Un metodo pubblico e statico che permette alle altre classi di accedere alla variabile del punto 2 e inizializzarla se ancora non creata.
Vediamo una semplice realizzazione in C#

public sealed class Singleton
{
    private static Singleton _instance = null;

    private Singleton()
    {
    }

    public static Singleton Instance
    {
        get
        {
            if (_instance==null)
            {
                _instance = new Singleton();
            }
            return _instance;
        }
    }
}

La proprietà Instance verifica se la variabile _instance è stata già inizializzata. In caso negativo provvede alla sua inizializzazione (new Singleton()). In ogni caso viene restituito il reiferimento stesso.
In questa maniera se siamo i primi a richiedere l'oggetto Singleton (Singleton.Instance) la classe inizializza l'oggetto e ce ne restituisce il riferimento. In caso contrario ci restituirà sempre il riferimento dell'unico oggetto presente.
In realtà il codice appena mostrato non considera l'eventualità che due threads si trovino contemporaneamente a dover valutare la condizione (_instance == null). In questo caso se dovessero verificare che l'oggetto non è stato inizializzato andrebbero a creare due istanze violando palesemente il pattern. In un contesto multi-threading il codice precedente non è sicuro e deve essere modificato ad esempio in questo modo:

public sealed class Singleton
{
    private static Singleton _instance=null;
    private static readonly object _padlock = new object();

    private Singleton()
    {
    }

    public static Singleton Instance
    {
        get
        {
            lock (_padlock)
            {
                if (_instance==null)
                {
                    _instance = new Singleton();
                }
                return _instance;
            }
        }
    }
}

L'introduzione di un lucchetto ci mette al riparo dalla possibilità che due thread valutino contemporaneamente la condizione di inizializzazione.
lunedì 4 ottobre 2010

Analista programmatore

La professione di analista programmatore consiste nel concepire e sviluppare un'applicazione informatica, cioè trasformare un bisogno in una soluzione informatica scritta in un  determinato linguaggio.
Storicamente, lo sviluppo informatico era assicurato da un capo progetto, incaricato dell'espressione dei bisogni, un analista, incaricato della modelizzazione e di un programmatore incaricato della codifica.
Le due funzioni di analista e programmatore sono oggi sempre più confuse, da cui la denominazione analista programmatore, sinonimo di sviluppatore.
La missione dello sviluppatore consiste quindi tanto nel far evolvere delle applicazioni esistenti quanto nel modelizzarne delle nuove.
La professione di cui stiamo parlando richiede delle conoscenze tecniche specifiche in sviluppo informatico, particolarmente in programmazione ad oggetti e in software engineering. E' necessaria la conoscenza della modelizzazione UML.
Lo sviluppatore deve ugualmente conoscere un linguaggio di programmazione, meglio più di uno, come Java (e l'ambiente J2EE), C++ o il Framework .NET.
venerdì 1 ottobre 2010

Unity - Microsoft Patterns & Practices

Dopo aver introdotto nel post precedente la Dependency Injection vorrei mostrarvi come utilizzare questo pattern nei vostri progetti in ambiente .NET.
La Microsoft mette a disposizione una libreria molto utile a riguardo: Unity.
Dopo aver scaricato e installato unity 2.0 siamo pronti ad utilizzarlo. Vediamo come fare nel classico caso di una applicazione web in ASP.NET.
  1. Aggiungere i riferimenti alle seguenti dll: Microsoft.Practices.Unity.dll e Microsoft.Practices.Unity.Configuration.dll
  2. Istruire il web.config della presenza di una nuova sezione dedicata a Unity:
    <configSections>
        ...
        <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration"/>
    </configSections>
  3. Aggiungere poi la sezione relativa a Unity nel web.config
    <unity>
        <containers>
            <container>
                <types>
                    <type type="WebSite.Model.MyInterface,
    WebSite.Model" mapTo="WebSite.Model.MyImplementation">
                    </type>
                </types>
            </container>
        </containers>
    </unity>

    E' proprio nel file xml di configurazione (web.config) che istruiamo Unity su come risolvere le nostre dipendenze. In pratica in questo esempio stiamo mappando (mapTo) i riferimenti all'interfaccia MyInterface con la classe MyImplementation. Entrambe queste classi sono definite nella dll WebSite.Model. Questi nomi dovranno evidentemente essere sostituiti con classi e interfacce reali del vostro progetto. Notiamo inoltre che in questo esempio stiamo mostrando la configurazione minima (mapping di una interfaccia con una classe) ma la libreria prevede altre interessanti possibilità di configurazione.
  4. In un progetto web è utile inserire il container di Unity nell'oggetto "Application" (System.Web.HttpApplicationState) per la richiesta Web corrente attraverso il file Global.asax:
    <%@ Application Language="C#" %>
    <%@ Import Namespace="Microsoft.Practices.Unity" %>
    <%@ Import Namespace="Microsoft.Practices.Unity.Configuration" %>

    <script RunAt="server">
        void Application_Start(object sender, EventArgs e)
        {
            // create and populate a new Unity container from configuration
            var container = new UnityContainer();
            var section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
            section.Configure(container);
            Application["Container"] = container;
        }

        void Application_End(object sender, EventArgs e)
        {
            //  Codice eseguito all\'arresto dell'applicazione
            Application["Container"] = null;
        }
       
        ...
    </script>
  5. A questo punto non ci resta che utilizzare l'interfaccia MyInterface lasciando il compito al container di Unity di risolvere la "Dependency". Nel code behind di una pagina aspx avremo qualcosa del tipo:
    ...
    private MyInterface _esempio;


    protected void Page_Load(object sender, EventArgs e)

    {

        _
    esempio = (Application["Container"] as IUnityContainer).Resolve<MyInterface>();
    }

    ...

    Potremo utilizzare così i metodi di MyInterface senza proccuparci di inizializzare la reference con un classe specifica: c'è Unity che lo fa per noi utilizzando le informazioni del web.config!
Prima di completare il post vorrei solo mostrarvi come dire a Unity che le nostre dependency devono essere risolte con un singolo oggetto per tipo. In pratica se vogliamo che le istanze siano dei Singleton basta aggiungere il seguente tag:
   <lifetime type="Microsoft.Practices.Unity.ContainerControlledLifetimeManager,
    Microsoft.Practices.Unity" /> 
All'interno del tag "type" contenente il mapping che vogliamo tradurre con un Singleton.
    giovedì 30 settembre 2010

    Introduzione alla Dependency Injection

    La Dependency Injection è un pattern di programmazione, nello specifico è una particolare forma del pattern Inversion Of Control. Con la Dependency Injection una classe non è responsabile dell'inizializzazione delle proprie dipendenze.
    Ma che cos'è una Dependency? Facciamo un esempio per chiarire le cose. Supponiamo di avere la seguente classe Macchina:

    public class Macchina
    {
        private Motore _motore;

        public void Macchina()
        {
        }

        public void Cammina()
        {
            ..
            _motore.Start();
            ..
        }
    }

    La variabile _motore è una Dependency per la classe Macchina. In pratica l'oggetto macchina dipende dall'oggetto motore (in effetti senza motore la macchina è poca cosa).
    In termini informatici la dipendenza (Dependency) non è altro che un campo di una classe (variabile di istanza) contenente il riferimento ad un oggetto esterno.
    Modifichiamo l'esempio precedente in questo modo:

    public class Macchina
    {
        private Motore _motore;

        public void Macchina(Motore motore)
        {
            _motore = motore;
        }

        public void Cammina()
        {
            ..
            _motore.Start();
            ..
        }
    }

    Attraverso il costruttore possiamo specificare il motore della nostra macchina: in effetti possiamo iniettare un oggetto Motore nella variabile di istanza _motore;
    L'Injection avviene proprio quando dall'esterno della classe che contiene la Dependency viene passata la dependency stessa già inizializzata. Vediamo come questo avviene:

    public class MacchinaTest
    {
        public static void Test()
        {
            Motore mo = new Motore();
            Macchina ma = new Macchina(mo);
            ma.Cammina();
        }
    }

    In questo caso la "Dependency Injection" è avvenuta tramite costruttore, ma tale tecnica può essere realizzata con un metodo "set" o tramite Interfaccia.

    Esistono infatti 3 tipi di Dependency Injection:
    1. Constructor Injection
    2. Setter Injection
    3. Interface Injection

    Database ad oggetti

    Volevo segnalarvi un interessante motore per database ad oggetti.
    Si chima db4o, è un progetto open-source e sono presenti sia una versione per Java che per .NET (2.0 e 3.5).
    Per chi non lo sapesse i database ad oggetti sono una valida alternativa ai database relazionali classici. I miglioramenti in fase di stesura del codice sono subito evidenti: gli oggetti che utiliziamo per creare i nostri programmi sono i dati che verranno salvati. Non c'è bisogno di tradurre il mondo ad oggetti nel modello relazionale tipico dei DBMS classici. Ecco un semplice esempio in C#:


    IObjectContainer db = Db4oEmbedded.OpenFile(Db4oEmbedded.NewConfiguration(), yapFileName);
    try 
    {
         db.Store(obj);
    }
    finally
    {
        db.Close();
    }


    Dove yapFileName è la stringa che contiene il percorso fisico del database (un singolo file con estensione .yap) e obj è il riferimento ad un qualsiasi oggetto del tuo modello.