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.