Carta di credito su internet

Spesso le informazioni che ci arrivano dai media e soprattutto dai telegiornali, sono storie sentite raccontare da altri, gonfiate e mal capite ed esposte che incutono paura al consumatore. Ad esempio:

E'sicuro usare la carta di credito su internet?

Il giorno prima di Pasqua ho avuto una discussione con amici di mio padre, i quali, non si fidano ad usare la carta di credito su web, perché hanno sentito al tg che non va bene e che si viene spesso e volentieri truffati.

La mia prima reazione è stata quella di tentare di rassicurarli spiegando che in realtà, esitono anche siti famosi e sicuri, nei quali si hanno vantaggi economici e si trovano prodotti altrimenti introvabili.

Un altro aspetto negativo è che questa mancanza di fiducia è alimentata dall'idea di voler tastare con mano il prodotto, prima di comprarlo.

Inoltre si ha il timore che una volta effettuato l'acquisto non ci siano garanazie nel caso arrivasse rotto o difettoso.

Per esperienza, sono anni ormai che faccio acquisti su internet e non ho mai avuto problemi. Per prima cosa se mi piace un prodotto, mi reco al primo centro commerciale per tastarmelo e provarlo. Nel caso non fosse disponibile, cerco eventuali video ed informazioni su YouTube o nei blog del settore di competenza.
Se decido di effettuare l'acquisto ci sono due strade da percorrere:

La prima è l'acquisto da siti più famosi tipo Amazon. Qui mi sento sicuro al 100% perché non ho mai avuto problemi ed inoltre quasi sempre il prezzo è nettamente inferiore rispetto ai comuni centri commerciali (per alcuni prodotti ho risparmiato anche 200 euro). Su amazon inoltre il prezzo di un prodotto è molto variabile di giorno in giorno.

E tutto semplicissimo. Mi basta accede al sito con le mie credenziali, guardare i prodotti, metterli nel carrello virtuale, completare l'acquisto fornendo il numero della carta di credito (la prima volta, poi viene memorizzata sul sito), e attendere il pacco comodo a casa in poltrona.

In caso di prodotto rotto o difettoso si hanno 30 giorni per restituirlo e farselo rimborsare. Passati i 30 giorni (ed entro 2 anni dati dalla garanzia e come qualsiasi altro prodotto acquistato in un normale negozio) bisogna cercare il più vicino centro di assistenza che si occupa della marca del prodotto acquistato (basta una piccola ricerca su Google per trovarlo).

Nel secondo caso cioè quello di siti sconosciuti ci sono un paio di regole da seguire ma niente di complicato:

- Prima di tutto dobbiamo fare una ricerca, per capire l'opinione della gente riguardo al negozio, se si sono trovati bene, in quanto tempo la merce ordinata è arrivata, se hanno avuto esperienze negative, se c'è e se è buona l'assistenza post vendita. Riassumendo è importante conoscere la reputazione online del negozio (feedback positivi e negativi).

- Bisogna confrontare l'offerta con quella di altri negozi e se è eccessivamente bassa stare molto attenti perché si tratta di una provabile trappola, o ci sono delle clausole nascoste. Molte volte ad esempio la tecnica di marketing usata è proporre un prezzo molto basso rispetto alla concorrenza, ma prima di terminare l'acquisto vi vengono richieste spese di spedizione molto alte che riportano la spesa totale allo stesso livello o superiore a quella dei concorrenti.

- Controllate che sia presente un servizio post vendita e che i numeri di telefono esitano veramente (si può contollare sul sito delle pagine bianche).

Una volta che avete appreso abbastanza informazioni e vi fidate, effettuate l'acquisto.

Se proprio vi va male denunciate l'accaduto alla polizia postale.

String format .NET semplificato e naturale

Molte volte ci troviamo a dover inserire delle stringhe in una stringa più grande (di solito una frase, per notificare un messaggio all’utente dell’applicazione).
Per fare ciò usiamo il metodo “String.Format()” che accetta in input la stringa da formattare, e un array contenete le altre stringhe da inserire, al posto di segna posti speciali, costruiti con la regola: {indice dell’array}.
Es.:

MessageBox.Show(String.Format("Errore numero {0}, l'utente {1}, non ha i permessi di lettura del file
 {2}, inoltre {1}, non appartiene al ruolo {3}", new String[]{"123", "Mario", "file.txt", "admin"}));

Di solito la scrittura di questo codice avviene nella seguente maniera:

1. Si scrive: MessageBox.Show(
2. Si pensa al messaggio e si inizia a scriverlo: "Errore numero …
3. Ci si accorge che il messaggio dovrà contenere dei pezzi di stringa all’interno della stringa principale.
4. Si aggiungono i segna posto per i pezzi di stringa: numero {0}, l'utente {1}, non
5. Completata la frase, ci si posiziona all’inizio della frase stessa.
6. Si digita String.Format(
7. Si va alla fine della frase e si chiude la parentesi )

Come si vede a lungo andare si perde molto tempo a compiere tale operazione e non è del tutto naturale, perché ci impegna a cercare l’inizio della frase scritta per aggiungere un pezzo di codice e a tornare alla fine di essa, per chiudere la parentesi.
Per risparmiare tempo e trovare più naturalezza nella scrittura, ho implementato la seguente classe per estendere la classe System.String:

namespace System
{
    /// <summary>
    /// Estensioni per le classi stringa
    /// </summary>
    public static class StringEx
    {
        /// <summary>
        /// Formatta la stringa
        /// </summary>
        /// <param name="pValue">Stringa</param>
        /// <param name="args">Parametri</param>
        /// <returns>Stringa formattata</returns>
        public static string Formatting(this String pValue, params object[] args)
        {
            return String.Format(pValue, args);
        }

        /// <summary>
        /// Formatta la stringa
        /// </summary>
        /// <param name="pValue">Stringa</param>
        /// <param name="format">Format provider</param>
        /// <param name="args">Parametri</param>
        /// <returns>Stringa formattata</returns>
        public static string Formatting(this String pValue, IFormatProvider format, params object[] args)
        {
            return String.Format(format, pValue, args);
        }
    }
}

Ora potere scrivere lo stesso codice dell’esempio di prima in maniera naturale, senza bisogno di tornare a cercare dove inizia la vostra Stringa:

MessageBox.Show("Errore numero {0}, l'utente {1}, non ha i permessi di lettura del file {2}, inoltre {1},
 non appartiene al ruolo {3}".Formatting(new String[] { "123", "Mario", "file.txt", "admin" }));

Implementare il Databindings di oggetti

Oggi mi è capitato di dover implementare il databindings di un controllo che ne era sprovvisto (il treenode). Per aggiungere il databindings ad un oggetto TreeNode, come nel mio caso, ma anche per qualsiasi altro oggetto, basta implementare l’interfaccia IBindableComponent.

In questo modo potete usare il Binding su tutte le proprietà del TreeNode; in particolare a me interessava collegare la proprietà “Name” di un mio oggetto alla proprietà “Text” di un TreeNode.

Ecco un esempio in C# dell’implementazione del databindings per la proprietà “Text” di un oggetto TreeNode:

public class TreeNodeBind : TreeNode, IBindableComponent
    {
        //Implementazione dei costruttori base
        public TreeNodeBind()
            : base()
        {
        }

        public TreeNodeBind(string text) 
            : base(text)
        {
        }

        public TreeNodeBind(string text, TreeNode[] children)
            : base(text, children)
        {
        }

        public TreeNodeBind(string text, int imgIndex, int selImgIndex) 
            : base(text, imgIndex, selImgIndex)
        {
        }

        public TreeNodeBind(string text, int imgIndex, int selImgIndex, TreeNode[] children)
            : base(text, imgIndex, selImgIndex, children)
        {
        }

        //Implementazione di IBindableComponent
        #region IBindableComponent Members

        private BindingContext _bindingContext;
        private ControlBindingsCollection _dataBindings;

        [Browsable(false)]
        public BindingContext BindingContext
        {
            get
            {
                if (_bindingContext == null)
                {
                    _bindingContext = new BindingContext();
                }
                return _bindingContext;
            }
            set
            {
                _bindingContext = value;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ControlBindingsCollection DataBindings
        {
            get { return _dataBindings ?? (_dataBindings = new ControlBindingsCollection(this)); }
        }

        public ISite Site { get; set; }

        public event EventHandler Disposed;

        public void Dispose()
        {
            if (Disposed != null)
                Disposed(this, EventArgs.Empty);
        }

        #endregion
    }

Ora potete creare ed usare nodi di tipo TreeNodeBind che supportano il Binding:

TreeNodeBind nodoBind = new TreeNodeBind();
nodoBind.DataBindings.Add(new System.Windows.Forms.Binding("Text", oggettoConDati, "Name", true));
tree.Nodes.Add(nodoBind);

Sviluppo Python su Android con SL4A

In questo articolo vi parlerò di come collegare un dispositivo Android al vostro PC windows per utilizzare da remoto SL4A, un programma che invia istruzioni in diversi linguaggi scripting (fra cui Python) ad Android tramite chiamate RPC e permette di scrivere programmi o pezzi di script direttamente sul dispositivo.

Per prima cosa scaricare e installare SL4A sul dispositivo Android. Lo potete trovare qui:
http://code.google.com/p/android-scripting/downloads/list
file: sl4a_r4.apk (o ultima versione)

Scarichiamo anche l'ultimo interprete del linguaggio Python:
http://code.google.com/p/python-for-android/downloads/list
file: PythonForAndroid_r6.apk (o ultima versione)

Sul PC installate Android SDK:
http://developer.android.com/sdk/index.html

Sul PC avviate Android SDK Manager e installate il driver USB:

Sul device andare in: "Impostazioni" -> "Applicazioni" -> "Sviluppo" -> e spuntare l'opzione "Debug USB"

Sul PC aggiungete "C:\Program Files (x86)\Android\android-sdk\tools\" alla variabile ambiente di windows PATH

Dal prompt di windows digitare "gestione dispositivi" e su "Altri dispositivi" tasto destro e "Aggiornamento software driver"
fare cerca nel computer nella cartella: "C:\Program Files (x86)\Android\android-sdk\extras\google\usb_driver" (o dove avete installato l'sdk)

Se il dispositivo non viene riconosciuto fate proprietà -> dettagli e annotardi le 2 righe con gli hardware id:

Aprite il file "android_winusb.inf" per inserire gli hardware id annotati in precedenza:.

Per il tablet iconia A500 come il mio aggiungete le seguenti righe:

(sia alla fine sella sezione [Google.NTx86] che di [Google.NTamd64])

;
;Iconia A500
%SingleAdbInterface% = USB_Install, USB\VID_0502&PID_3325
%CompositeAdbInterface% = USB_Install, USB\VID_0502&PID_3325&MI_01

ripetete il riconoscimento del driver, tramite aggiornamento ed ora verrà trovato:

fate una prova lanciando il comando dal prompt di windows (con privilegi di amministratore): adb devices
dovrebbe restituirvi una stringa che rappresenta l'id del dispositivo connesso

Avviamo SL4A dal dispositivo Android. Ora dal menu del programma selezionate: View -> Interpreters
premiamo di nuovo il bottone menu, selezioniamo "start server". Selezioniamo "private" (public è usato per la connessione via wifi).

Ora siamo pronti alla connessione:
per prima cosa dobbiamo creare la seguente variabile d'ambiente per utente: AP_PORT con valore di default: 9999, poi abilitare il port forwarding

Nel caso abbiate un tablet cliccate sull'icona di SL4A nella tray e poi nel riquadro nero che compare per vedere a video il numero della porta usata dal server del dispositivo:

Aggiungiamo alla variabile d'ambiente PATH anche il percorso del file della shell Python Es.: ";C:\Python26"

Nella cartella lib della cartella dove avete installato Python Es.: "C:\Python26\Lib" salviamo il file "android.py"

Sul PC lanciamo un prompt windows come amministratore e digitiamo:

set AP_PORT=9999
adb forward tcp:9999 tcp:[numero di porta server SL4A]
python

Ora la vostra shell Python esegue i comandi sul dispositivo Android.

Ecco il codice per una piccola prova che stampa sul video del dispositivo il messaggio "Ciao sono il PC!"

import android  # dal file android.py che abbiamo aggiunto sul PC
droid = android.Android()
droid.makeToast("Ciao sono il PC!")

Appunti base relativi ai Design Patterns

Appunti sui Design patterns:

appunti design patterns

I design patterns sono suddivisi in queste tre principali categorie:

Creationals (Creazionali):

• Permettono di astrarre il processo di creazione degli oggetti
• Rendono un sistema indipendente da come i suoi oggetti sono stati creati, composti e rappresentati
• Incapsulano la conoscenza sulle classi concrete che un sistema usa
• Nascondono l'implementazione delle classi e della loro creazione

da immagine appunti design patterns

1.1, Creational
  1.1.1, AbstractFactory
    1.1.1.1, Crea oggetti che appartengono alla stessa famiglia e sono connessi o dipendenti tra loro
    1.1.1.2, Possibilità di utilizzare una famiglia diversa di prodotti a seconda della factory usata. L'interfaccia del client non cambia
  1.1.2, FactoryMethod
    1.1.2.1, Fornische un interfaccia per creare un oggetto ma sono le sottoclassi a decidere cosa istanziare
  1.1.3, Prototype
    1.1.3.1, Crea nuovi oggetti clonando quello base
  1.1.4,  Builder
    1.1.4.1, Separa la costruzione di un oggetto complesso dalla sua rappresentazione.  Lo stesso costruttore puó creare più rappresentazioni diverse
  1.1.5, Singleton 
    1.1.5.1, Fa in modo che una classe abbia una sola istanza e possa essere usata da tutti

Structural (Strutturali):

• Sono dedicati alla composizione di classi e oggetti per creare delle strutture più grandi
• Gli Structural class pattern utilizzando l'ereditarietà per creare interfacce o implementazioni
• Gli Structural object pattern descrivono il modo in cui comporre gli oggetti per realizzare nuove funzionalità

da immagine appunti design patterns

1.2, Structural
  1.2.1, Proxy
    1.2.1.1, Inizializzare un oggetto solo quando viene chiamato il metodo
  1.2.2, Bridge
    1.2.2.1, Separa cosa si puó fare da cosa si fà
    1.2.2.2, Permette di eseguire la stessa operazione ma in maniera diversa a seconda del caso
    1.2.2.3, Costruisce un oggetto composto da varie parti.  Le parti che servono sono dinamiche a seconda del builder usato
  1.2.3, Facade
    1.2.3.1, Interfaccia di alto livello per richiamare sottosistemi diversi
  1.2.4, Adapter
    1.2.4.1, Adatta l'interfaccia di un elemento alla richiesta del client
  1.2.5, Decorator
    1.2.5.1, Aggiunge metodi all'oggetto in maniera dinamica
    1.2.5.2, Propone alternativa all'ereditarietà (anche multipla)
  1.2.6, Flyweight
    1.2.6.1, Condivide la parte riusabile di un oggetto
    1.2.6.2, La factory estra un oggetto dalla collezione interna o lo crea nuovo per risparmiare memoria, istanziando l'oggetto normalmente si accede alla parte non condivisa
  1.2.7, Composite
    1.2.7.1, Crea oggetti in strutture ad albero
    1.2.7.2, Esempio: il trapezio è composto da 2 triangoli e un rettangolo

Behavioral (Comportamentali):

• Si focalizzano sul controllo di flusso degli oggetti
• Descrivono le comunicazioni fra gli oggetti
• Aiutano a valutare le responsabilità assegnate agli oggetti
• Suggeriscono modi per incapsulare algoritmi dentro classi

da immagine appunti design patterns

1.3, Behavioral
  1.3.1, TemplateMethod
    1.3.1.1, Permette di variare una parte di un algoritmo e non toccare il resto
  1.3.2, Strategy
    1.3.2.1, Crea una classe con algoritmi intercambiabili ma interfaccia per richiamarli uguale
  1.3.3, Observer
    1.3.3.1, Crea eventi che si scatenano in tutti gli oggetti registrati quando viene notificato dall'oggetto principale
  1.3.4, Mediator
    1.3.4.1, Permette l'iterazione fra oggetti senza che uno abbia a che fare con l'altro
    1.3.4.2, L'oggetto principale incapsula l'iterazione fra gli oggetti contenuti
  1.3.5, State
    1.3.5.1, Cambia il comportamento a run-time dell'oggetto a seconda dello stato in cui si trova
  1.3.6, Interpreter
    1.3.6.1, Trasforma una sintassi, un linguaggio in entrata e interpretandone le espressioni produce un risultato in uscita
    1.3.6.2, L'interpreter precisa come valutare le frasi in una determinata lingua o linguaggio
  1.3.7, Visitor
    1.3.7.1, Rappresenta un operazione che puó essere eseguita sugli elementi di una struttura oggetto. 
    1.3.7.2, Permette di definire una nuova operazione senza modificare la struttura stessa
    1.3.7.3, Delega una funzionalità a una gerarchia di classi senza inquinarle
    1.3.7.4, Separa un algoritmo dalla struttura di oggetti compositi a cui è applicato
    1.3.7.5, Il visitor incapsula la funzionalità e la gerarchia viene dotata solo di un metodo per accedere ad uno di questi visitor
  1.3.8, Command
    1.3.8.1, Isola la porzione di codice che effettua un azione dal codice che ne richiede l'esecuzione; l'azione è incapsulata nell'oggetto command
    1.3.8.2, Utile da usare per associare azioni dell'interfaccia grafica(esempio click sul un bottone) al codice che esegue l'azione
  1.3.9, Iterator
    1.3.9.1, Fornisce un metodo per accedere agli oggetti di una collezione senza esporli direttamente
  1.3.10, Memento
    1.3.10.1, Estrae lo stato di un oggetto per ripristinarlo successivamente (come undo)
  1.3.11, Chain of responsability
    1.3.11.1, Separa oggetti che fanno le richieste da quelli che le gestiscono
    1.3.11.2, Usa un determinato oggetto che si incarica di soddisfare la richiesta effettuata

Factory Method Design Pattern in pratica

Il Factory Method, fa parte dei creational patterns, esso consente di utilizzare un'interfaccia per la creazione di un oggetto, ma sono le sottoclassi a decidere quale classe istanziare.
L’obbiettivo principale è l’estensibilità, consente di istanziare un oggetto senza specificare una classe.
Il Factory Method è spesso utilizzato in applicazioni che:

• necessitano che la creazione o la rappresentazione di oggetti sia nascosta ed indipendente dalla struttura principale.
• gestiscono, mantengono, o manipolano collezioni di oggetti diverse, ma con molte caratteristiche in comune.
• se il sistema principale viene modificato si possono modificare facilmente anche le caratteristiche comuni fra gli oggetti
• forniscono una libreria di classi in cui è visibile solo l’interfaccia, ma non l’implementazione della classe

Ci sono 3 regole principali che il pattern Factory Method deve rispettare:

1. Il metodo crea un nuovo oggetto
2. Il metodo ritorna una classe astratta o un interfaccia
3. La classe astratta o l’interfaccia viene implementata da più classi

Ora vediamo un piccolo esempio di implementazione per capire meglio come funziona il pattern Factory Method nei seguenti linguaggi:
(questi ultimi due comunque non supportano interfacce o classi astratte, quindi bisogna prestare la massima attenzione all’implementazione, magari usando una buona convenzione sui nomi delle classi e dei metodi, in maniera di evitare di utilizzare classi o metodi sbagliati per distrazione)

Diagramma UML:
In un nuovo progetto di tipo Console aggiungo il file “Persona” e creo la classe persona (questa classe sarà usata anche nei miei prossimi post sui design patterns):

//C#
using System;

namespace Netrudy.Patterns
{
    //Classe che rappresenta una persona fisica
    class Persona
    {
        //Costruttore
        public Persona(string nome, string cognome)
        {
            this.Nome = nome;
            this.Cognome = cognome;
        }

        //Nome
        public String Nome { get; set; }

        //Cognome
        public String Cognome { get; set; }
    }
}

'VB.NET
Namespace Netrudy.Patterns
    'Classe che rappresenta una persona fisica
    Class Persona
        'Costruttore
        Public Sub New(nome As String, cognome As String)
            Me.Nome = nome
            Me.Cognome = cognome
        End Sub

        'Nome
        Public Property Nome() As [String]
            Get
                Return m_Nome
            End Get
            Set(value As [String])
                m_Nome = value
            End Set
        End Property
        Private m_Nome As [String]

        'Cognome
        Public Property Cognome() As [String]
            Get
                Return m_Cognome
            End Get
            Set(value As [String])
                m_Cognome = value
            End Set
        End Property
        Private m_Cognome As [String]
    End Class
End Namespace

//Java
package Netrudy.Patterns;

//Classe che rappresenta una persona fisica
public class Persona
{
    //Costruttore
    public Persona(String nome, String cognome)
    {
        this.setNome(nome);
        this.setCognome(cognome);
    }

    //Nome
    private String privateNome;
    public final String getNome()
    {
        return privateNome;
    }
    public final void setNome(String value)
    {
        privateNome = value;
    }

    //Cognome
    private String privateCognome;
    public final String getCognome()
    {
        return privateCognome;
    }
    public final void setCognome(String value)
    {
        privateCognome = value;
    }
}

//C++/CLI file .h
#pragma once

using namespace System;

namespace Netrudy
{
    namespace Patterns
    {
        //Classe che rappresenta una persona fisica
        private ref class Persona
        {
            //Costruttore
        public:
            Persona(String ^nome, String ^cognome);

            //Nome
            property String ^Nome;

            //Cognome
            property String ^Cognome;
        };
    }
}

//file .cpp
#include "Persona.h"

using namespace System;
namespace Netrudy
{
    namespace Patterns
    {

        Persona::Persona(String ^nome, String ^cognome)
        {
            this->Nome = nome;
            this->Cognome = cognome;
        }
    }
}

//C++ Nativo file .h
#pragma once

#include <string>

namespace Netrudy
{
    namespace Patterns
    {
        //Classe che rappresenta una persona fisica
        class Persona
        {
            //Costruttore
        public:
            Persona(const std::string &nome, const std::string &cognome);

            //Nome
            private:
                std::string privateNome;
            public:
                std::string getNome();
                void setNome(const std::string &value);

            //Cognome
            private:
                std::string privateCognome;
            public:
                std::string getCognome();
                void setCognome(const std::string &value);
        };
    }
}

//file .cpp
#include "Persona.h"

namespace Netrudy
{
    namespace Patterns
    {

        Persona::Persona(const std::string &nome, const std::string &cognome)
        {
            this->Nome = nome;
            this->Cognome = cognome;
        }

        std::string Persona::getNome()
        {
            return privateNome;
        }

        void Persona::setNome(const std::string &value)
        {
            privateNome = value;
        }

        std::string Persona::getCognome()
        {
            return privateCognome;
        }

        void Persona::setCognome(const std::string &value)
        {
            privateCognome = value;
        }
    }
}

#Python
"""Classe che rappresenta una persona fisica"""
class Persona(object):
    
    #Costruttore
    def __init__(self, nome, cognome):
        self._nome = nome
        self._cognome = cognome

    #Nome
    def getNome(self):
        return self._nome

    def setNome(self, value):
        self._nome = value

    Nome = property(getNome, setNome)

    #Cognome
    def getCognome(self):
        return self._cognome

    def setCognome(self, value):
        self._cognome = value

    Cognome = property(getCognome, setCognome)

//Javascript
//Classe che rappresenta una persona fisica
//Costruttore
Netrudy.Patterns._persona = function Netrudy_Patterns__persona(nome, cognome) {
    this.set_nome(nome);
    this.set_cognome(cognome);
}
Netrudy.Patterns._persona.prototype = {
    //Nome
    _nome: null,
    
    get_nome: function Netrudy_Patterns__persona$get_nome() {
        return this._nome;
    },
    set_nome: function Netrudy_Patterns__persona$set_nome(value) {
        this._nome = value;
        return value;
    },
    
    //Cognome
    _cognome: null,
    
    get_cognome: function Netrudy_Patterns__persona$get_cognome() {
        return this._cognome;
    },
    set_cognome: function Netrudy_Patterns__persona$set_cognome(value) {
        this._cognome = value;
        return value;
    }
}

N.B.: Per Javascript ho usato Script#: http://projects.nikhilk.net/ScriptSharp alcune funzioni utilizzano parte di codice della libreria “mscorlib.js” di Script#, che è un misto di AJAX e funzioni di .NET Framework riadattate al Javascript (per esempio le collezioni Enumerable).
Aggiungiamo il file “FactoryMethod” e iniziamo a scrivere il seguente codice:
Dichiaro gli oggetti dipendente e datore di lavoro che derivano da persona (e rappresentano delle persone fisiche) questi sono i nostri oggetti nascosti:

//C#
//Personale di tipo: dipendente
class ConcreteDipendente : Persona
{
    public ConcreteDipendente(string nome, string cognome)
        : base(nome, cognome) {}
}

//Personale di tipo: datore di lavoro
class ConcreteDatoreDiLavoro : Persona
{
    public ConcreteDatoreDiLavoro(string nome, string cognome)
        : base(nome, cognome) {}
}

'VB.NET
'Personale di tipo: dipendente
Class ConcreteDipendente
    Inherits Persona
    Public Sub New(nome As String, cognome As String)
        MyBase.New(nome, cognome)
    End Sub
End Class

'Personale di tipo: datore di lavoro
Class ConcreteDatoreDiLavoro
    Inherits Persona
    Public Sub New(nome As String, cognome As String)
        MyBase.New(nome, cognome)
    End Sub
End Class

//Java
//Personale di tipo: datore di lavoro
public class ConcreteDatoreDiLavoro extends Persona
{
    public ConcreteDatoreDiLavoro(String nome, String cognome)
    {
        super(nome, cognome);
    }
}

//Personale di tipo: dipendente
public class ConcreteDipendente extends Persona
{
    public ConcreteDipendente(String nome, String cognome)
    {
        super(nome, cognome);
    }
}

//C++/CLI file .h
//Personale di tipo: dipendente
private ref class ConcreteDipendente : Persona
{
public:
    ConcreteDipendente(String ^nome, String ^cognome);
};

//Personale di tipo: datore di lavoro
private ref class ConcreteDatoreDiLavoro : Persona
{
public:
    ConcreteDatoreDiLavoro(String ^nome, String ^cognome);
};

//file .cpp
ConcreteDipendente::ConcreteDipendente(String ^nome, String ^cognome) : Persona(nome, cognome)
{
}

ConcreteDatoreDiLavoro::ConcreteDatoreDiLavoro(String ^nome, String ^cognome) : Persona(nome, cognome)
{
}

//C++ Nativo file .h
//Personale di tipo: dipendente
class ConcreteDipendente : public Persona
{
public:
    ConcreteDipendente(const std::string &nome, const std::string &cognome);
};

//Personale di tipo: datore di lavoro
class ConcreteDatoreDiLavoro : public Persona
{
public:
    ConcreteDatoreDiLavoro(const std::string &nome, const std::string &cognome);
};

// file .cpp
ConcreteDipendente::ConcreteDipendente(const std::string &nome, const std::string &cognome) : Persona(nome, cognome)
{
}

ConcreteDatoreDiLavoro::ConcreteDatoreDiLavoro(const std::string &nome, const std::string &cognome) : Persona(nome, cognome)
{
}

#Python
#Personale di tipo: dipendente
class ConcreteDipendente(Persona):

    def __init__(self, nome, cognome):
        Persona.__init__(self, nome, cognome)
        
#Personale di tipo: datore di lavoro
class ConcreteDatoreDiLavoro(Persona):

    def __init__(self, nome, cognome):
        Persona.__init__(self, nome, cognome)

//Javascript
//Personale di tipo: dipendente
Netrudy.Patterns._concreteDipendente = function Netrudy_Patterns__concreteDipendente(nome, cognome) {
    Netrudy.Patterns._concreteDipendente.initializeBase(this, [ nome, cognome ]);
}
//Personale di tipo: datore di lavoro
Netrudy.Patterns._concreteDatoreDiLavoro = function Netrudy_Patterns__concreteDatoreDiLavoro(nome, cognome) {
    Netrudy.Patterns._concreteDatoreDiLavoro.initializeBase(this, [ nome, cognome ]);
}

Come possiamo notare se c’è un costruttore nella classe base (persona) è necessario implementarlo anche nelle classi derivate.
Queste due classi appena create sono quelle concrete, cioè quelle con i campi e i metodi delle persone, e verranno create o meno a seconda di cosa scriveremo nel metodo di creazione FactoryMethod che implementeremo derivando la nostra nuova classe dalla seguente classe astratta:

//C#
//Classe astratta che rappresenta il personale dell'azienda
abstract class PersonaleAziendaCreator
{
    //Costruttore che chiama il metodo astratto
    //FactoryMethod
    //che verrà implementato nella classe figlia
    protected PersonaleAziendaCreator()
    {
        Persone = new List();
        this.FactoryMethod();
    }

    //Metodo astratto da implementare
    protected abstract void FactoryMethod();

    //Lista del personale aziendale (che sarà legato
    //alla categoria della classe figlia)
    public List Persone { get; protected set; }
}

'VB.NET
'Classe astratta che rappresenta il personale dell'azienda
MustInherit Class PersonaleAziendaCreator
    'Costruttore che chiama il metodo astratto FactoryMethod
    'che verrà implementato nella classe figlia
    Protected Sub New()
        Persone = New List(Of Persona)()
        Me.FactoryMethod()
    End Sub

    'Metodo astratto da implementare
    Protected MustOverride Sub FactoryMethod()

    'Lista del personale aziendale (che sarà legato alla categoria della classe figlia)
    Public Property Persone() As List(Of Persona)
        Get
            Return m_Persone
        End Get
        Protected Set(value As List(Of Persona))
            m_Persone = Value
        End Set
    End Property
    Private m_Persone As List(Of Persona)
End Class

//Java
//Classe astratta che rappresenta il personale dell'azienda
public abstract class PersonaleAziendaCreator
{
    //Costruttore che chiama il metodo astratto FactoryMethod
    //che verrà implementato nella classe figlia
    protected PersonaleAziendaCreator()
    {
        setPersone(new java.util.ArrayList<Persona>());
        this.FactoryMethod();
    }

    //Metodo astratto da implementare
    protected abstract void FactoryMethod();

    //Lista del personale aziendale (che sarà legato alla categoria della classe figlia)
    private java.util.ArrayList<Persona> privatePersone;
    public final java.util.ArrayList<Persona> getPersone()
    {
        return privatePersone;
    }
    protected final void setPersone(java.util.ArrayList<Persona> value)
    {
        privatePersone = value;
    }
}

//C++/CLI file .h
//Classe astratta che rappresenta il personale dell'azienda
private ref class PersonaleAziendaCreator abstract
{
    //Costruttore che chiama il metodo astratto FactoryMethod
    //che verrà implementato nella classe figlia
protected:
    PersonaleAziendaCreator();

    //Metodo astratto da implementare
    virtual void FactoryMethod() abstract;

    //Lista del personale aziendale (che sarà legato alla categoria della classe figlia)
public:
    property List<Persona^> ^Persone;
};

//file .cpp
PersonaleAziendaCreator::PersonaleAziendaCreator()
{
    Persone = gcnew List<Persona^>();
    this->FactoryMethod();
}

//C++ Nativo file .h
//Classe astratta che rappresenta il personale dell'azienda
class PersonaleAziendaCreator
{
    //Costruttore che chiama il metodo astratto FactoryMethod
    //che verrà implementato nella classe figlia
protected:
    PersonaleAziendaCreator();

    //Metodo astratto da implementare
    virtual void FactoryMethod() = 0;

    //Lista del personale aziendale (che sarà legato alla categoria della classe figlia)
    private:
        std::vector<Persona*> privatePersone;
    public:
        std::vector<Persona*> getPersone();
        void setPersone(std::vector<Persona*> value);
};

//file .cpp
PersonaleAziendaCreator::PersonaleAziendaCreator()
{
    Persone = std::vector<Persona*>();
    this->FactoryMethod();
}

std::vector<Persona*> PersonaleAziendaCreator::getPersone()
{
    return privatePersone;
}

void PersonaleAziendaCreator::setPersone(std::vector<Persona*> value)
{
    privatePersone = value;
}

#Python
"""Classe astratta che rappresenta il personale dell'azienda"""
#Python non supporta interfacce o classi astratte quindi utilizziamo il seguente workaround
class PersonaleAziendaCreator(object):

def __init__(self):
    self._persone = []
    self.FactoryMethod()

#workaround per metodo astratto
def FactoryMethod(self, arg):
    raise NotImplementedError("Metodo astratto!")

def getPersone(self):
    return self._persone

def setPersone(self, value):
    self._persone = value

Persone = property(getPersone, setPersone)

//Javascript
//Classe che rappresenta il personale dell'azienda
Netrudy.Patterns._personaleAziendaCreator = function Netrudy_Patterns__personaleAziendaCreator() {
    this.set_persone([]);
    //Metodo astratto da implementare
    this.factoryMethod();
}
Netrudy.Patterns._personaleAziendaCreator.prototype = {
    _persone: null,
    
    //Lista del personale aziendale (che sarà legato alla categoria della classe figlia)
    get_persone: function Netrudy_Patterns__personaleAziendaCreator$get_persone() {
        return this._persone;
    },
    set_persone: function Netrudy_Patterns__personaleAziendaCreator$set_persone(value) {
        this._persone = value;
        return value;
    }
}

Ora creiamo le classi di creazione del personale dell’azienda che implementeranno il FactoryMethod poiché derivando dalla classe base PersonaleAziendaCreator:

//C#
//Classe che si occupa di creare i dipendenti
//dell'azienda
class ConcreteCreatorDipendente : PersonaleAziendaCreator
{
    protected override void FactoryMethod()
    {
        Persone.Add(new ConcreteDipendente("Luigi", "Bross"));
        Persone.Add(new ConcreteDipendente("Toad", "Fungo"));
    }
}

//Classe che si occupa di creare i datori di lavoro 
//dell'azienda
class ConcreteCreatorDatoreDiLavoro : PersonaleAziendaCreator
{
    protected override void FactoryMethod()
    {
        Persone.Add(new ConcreteDatoreDiLavoro("Mario", "Boss"));
    }
}

'VB.NET
'Classe che si occupa di creare i dipendenti dell'azienda
Class ConcreteCreatorDipendente
    Inherits PersonaleAziendaCreator
    Protected Overrides Sub FactoryMethod()
        Persone.Add(New ConcreteDipendente("Luigi", "Bross"))
        Persone.Add(New ConcreteDipendente("Toad", "Fungo"))
    End Sub
End Class

'Classe che si occupa di creare i datori di lavoro dell'azienda
Class ConcreteCreatorDatoreDiLavoro
    Inherits PersonaleAziendaCreator
    Protected Overrides Sub FactoryMethod()
        Persone.Add(New ConcreteDatoreDiLavoro("Mario", "Boss"))
    End Sub
End Class

//Java
//Classe che si occupa di creare i dipendenti dell'azienda
public class ConcreteCreatorDipendente extends PersonaleAziendaCreator
{
    @Override
    protected void FactoryMethod()
    {
        getPersone().add(new ConcreteDipendente("Luigi", "Bross"));
        getPersone().add(new ConcreteDipendente("Toad", "Fungo"));
    }
}

//Personale di tipo: datore di lavoro
public class ConcreteDatoreDiLavoro extends Persona
{
    public ConcreteDatoreDiLavoro(String nome, String cognome)
    {
        super(nome, cognome);
    }
}

//C++/CLI file .h
//Classe che si occupa di creare i dipendenti dell'azienda
private ref class ConcreteCreatorDipendente : PersonaleAziendaCreator
{
protected:
    virtual void FactoryMethod() override;
};

//Classe che si occupa di creare i datori di lavoro dell'azienda
private ref class ConcreteCreatorDatoreDiLavoro : PersonaleAziendaCreator
{
protected:
    virtual void FactoryMethod() override;
};

//file .cpp
void ConcreteCreatorDipendente::FactoryMethod()
{
    Persone->Add(gcnew ConcreteDipendente("Luigi", "Bross"));
    Persone->Add(gcnew ConcreteDipendente("Toad", "Fungo"));
}

void ConcreteCreatorDatoreDiLavoro::FactoryMethod()
{
    Persone->Add(gcnew ConcreteDatoreDiLavoro("Mario", "Boss"));
}

//C++ Nativo file .h
//Classe che si occupa di creare i dipendenti dell'azienda
class ConcreteCreatorDipendente : public PersonaleAziendaCreator
{
protected:
    virtual void FactoryMethod();
};

//Classe che si occupa di creare i datori di lavoro dell'azienda
class ConcreteCreatorDatoreDiLavoro : public PersonaleAziendaCreator
{
protected:
    virtual void FactoryMethod();
};

//file .cpp
void ConcreteCreatorDipendente::FactoryMethod()
{
    Persone->Add(new ConcreteDipendente("Luigi", "Bross"));
    Persone->Add(new ConcreteDipendente("Toad", "Fungo"));
}

void ConcreteCreatorDatoreDiLavoro::FactoryMethod()
{
    Persone->Add(new ConcreteDatoreDiLavoro("Mario", "Boss"));
}

#Python
#Classe che si occupa di creare i dipendenti dell'azienda
class ConcreteCreatorDipendente(PersonaleAziendaCreator):

    def FactoryMethod(self):
        self.Persone.append(ConcreteDipendente("Luigi", "Bross"))
        self.Persone.append(ConcreteDipendente("Toad", "Fungo"))

#Classe che si occupa di creare i datori di lavoro dell'azienda
class ConcreteCreatorDatoreDiLavoro(PersonaleAziendaCreator):

    def FactoryMethod(self):
        self.Persone.append(ConcreteDatoreDiLavoro("Mario", "Boss"))

//Javascript
//Classe che si occupa di creare i dipendenti dell'azienda


Netrudy.Patterns._concreteCreatorDipendente = function Netrudy_Patterns__concreteCreatorDipendente() {
    Netrudy.Patterns._concreteCreatorDipendente.initializeBase(this);
}
Netrudy.Patterns._concreteCreatorDipendente.prototype = {
    
    factoryMethod: function Netrudy_Patterns__concreteCreatorDipendente$factoryMethod() {
        this.get_persone().add(new Netrudy.Patterns._concreteDipendente('Luigi', 'Bross'));
        this.get_persone().add(new Netrudy.Patterns._concreteDipendente('Toad', 'Fungo'));
    }
}

//Classe che si occupa di creare i datori di lavoro dell'azienda
Netrudy.Patterns._concreteCreatorDatoreDiLavoro = function Netrudy_Patterns__concreteCreatorDatoreDiLavoro() {
    Netrudy.Patterns._concreteCreatorDatoreDiLavoro.initializeBase(this);
}
Netrudy.Patterns._concreteCreatorDatoreDiLavoro.prototype = {
    
    factoryMethod: function Netrudy_Patterns__concreteCreatorDatoreDiLavoro$factoryMethod() {
        this.get_persone().add(new Netrudy.Patterns._concreteDatoreDiLavoro('Mario', 'Boss'));
    }
}

A questo punto proviamo il programma implementando il metodo main del nostro progetto:

//C#
//Istanzio la classe per creare i dipendenti
PersonaleAziendaCreator creaDipendenti = new ConcreteCreatorDipendente();
//Istanzio la classe per creare i datori di lavoro
PersonaleAziendaCreator creaDatori = new ConcreteCreatorDatoreDiLavoro();

//Unisco il gruppo di persone create
List persone = new List(creaDatori.Persone.Union(creaDipendenti.Persone));

//Per ogni persona scrive a video il tipo di oggetto 
//della persona e il nome
foreach (Persona persona in persone)
{
    Console.WriteLine("Persona (di tipo: {0}): {1}", persona.GetType(), persona.Nome);
}

'VB.NET
'Istanzio la classe per creare i dipendenti
Dim creaDipendenti As PersonaleAziendaCreator = New ConcreteCreatorDipendente()
'Istanzio la classe per creare i datori di lavoro
Dim creaDatori As PersonaleAziendaCreator = New ConcreteCreatorDatoreDiLavoro()

'Unisco il gruppo di persone create
Dim persone As New List(Of Persona)(creaDatori.Persone.Union(creaDipendenti.Persone))

'Per ogni persona scrive a video il tipo di oggetto della persona e il nome
For Each persona As Persona In persone
    Console.WriteLine("Persona (di tipo: {0}): {1}", persona.[GetType](), persona.Nome)
Next

//Java
//Istanzio la classe per creare i dipendenti
PersonaleAziendaCreator creaDipendenti = new ConcreteCreatorDipendente();
//Istanzio la classe per creare i datori di lavoro
PersonaleAziendaCreator creaDatori = new ConcreteCreatorDatoreDiLavoro();

//Unisco il gruppo di persone create
java.util.ArrayList<Persona> persone = new java.util.ArrayList<Persona>(creaDatori.getPersone().Union(creaDipendenti.getPersone()));

//Per ogni persona scrive a video il tipo di oggetto della persona e il nome
for (Persona persona : persone)
{
    System.out.println("Persona (di tipo: {0}): {1}", persona.getClass(), persona.getNome());
}

//C++/CLI file .cpp
//Istanzio la classe per creare i dipendenti
PersonaleAziendaCreator ^creaDipendenti = gcnew ConcreteCreatorDipendente();
//Istanzio la classe per creare i datori di lavoro
PersonaleAziendaCreator ^creaDatori = gcnew ConcreteCreatorDatoreDiLavoro();

//Unisco il gruppo di persone create
List<Persona^> ^persone = gcnew List<Persona^>(creaDatori->Persone->Union(creaDipendenti->Persone));

//Per ogni persona scrive a video il tipo di oggetto della persona e il nome
for each (Persona ^persona in persone)
{
    Console::WriteLine("Persona (di tipo: {0}): {1}", persona->GetType(), persona->Nome);
}

//C++ Nativo .cpp
//Istanzio la classe per creare i dipendenti
PersonaleAziendaCreator *creaDipendenti = new ConcreteCreatorDipendente();
//Istanzio la classe per creare i datori di lavoro
PersonaleAziendaCreator *creaDatori = new ConcreteCreatorDatoreDiLavoro();

//Unisco il gruppo di persone create
std::vector<Persona*> persone = std::vector<Persona*>(creaDatori->Persone->Union(creaDipendenti->Persone));

//Per ogni persona scrive a video il tipo di oggetto della persona e il nome
for (std::vector<Persona*>::const_iterator persona = persone.begin(); persona != persone.end(); ++persona)
{
    std::cout << "Persona (di tipo: " << (*persona)->GetType() << "): " << (*persona)->Nome << std::endl;
}

#Python
#Istanzio la classe per creare i dipendenti
creaDipendenti = ConcreteCreatorDipendente()
#Istanzio la classe per creare i i datori di lavoro
creaDatori = ConcreteCreatorDatoreDiLavoro()

#Unisco il gruppo di persone create
persone = list(set(creaDipendenti.getPersone()) | set(creaDatori.getPersone()))

#Per ogni persona scrive a video il tipo di oggetto della persona e il nome
for persona in persone:
    print "Persona (di tipo: {0})): {1}".format(type(persona), persona.Nome)

//Javascript
//Istanzio la classe per creare i dipendenti
var creaDipendenti = new Netrudy.Patterns._concreteCreatorDipendente();
//Istanzio la classe per creare i datori di lavoro
var creaDatori = new Netrudy.Patterns._concreteCreatorDatoreDiLavoro();
//Unisco il gruppo di persone create
var persone = creaDipendenti.get_persone().concat(creaDatori.get_persone());
//Per ogni persona scrive a video il tipo di oggetto della persona e il nome
var $enum1 = ss.IEnumerator.getEnumerator(persone);
while ($enum1.moveNext()) {
    var persona = $enum1.current;
    ss.Debug.writeln(String.format('Persona (di tipo: {0}): {1}', Type.getInstanceType(persona), persona.get_nome()));
}

Istallazione Windows 8 Developer Preview with developer tools 64bit su VMWare Workstation 8

Per prima cosa scarichiamo l’immagine ISO da qui: Windows 8 Developer Preview with developer tools English, 64-bit (x64)
Avviamo VMware Workstation, e selezioniamo dal menu file, nuova, virtual machine, in questo modo partirà il wizard di creazione.

Scegliamo tipical e premiamo next.
A questo punto selezioniamo installer disk image file (iso) e selezioniamo il percorso del file dove si trova la nostra immagine scaricata:

Nella fase successiva selezioniamo Miscrosoft Windows dalla lista dei sistemi operativi e Windows 7 64-bit dalla lista delle versioni:

Lasciamo libero il product key di windows e scriviamo una nostra password:

Diamo un nome alla nostra macchina virtuale e selezioniamo un percorso dove verranno salvati i files:

Selezioniamo la quantità di memoria del disco rigido virtuale, desiderata (io avendo spazio ho messo 40gb, ma credo bastino 20), e se vogliamo che il disco sia diviso in più files o su uno solo:

A questo punto rileggiamo se abbiamo impostato tutto correttamente e premiamo Finish per fare partire la macchina virtuale.

Se è andato tutto bene dovreste vedere partire l’installazione di Windows 8:

Ad un certo punto però otterrete questo messaggio d’errore:

Spegnete la macchina virtuale, andate nelle menu delle impostazioni (VM –> Settings), e rimuovete il Floppy dall’elenco dei devices:

Date OK e riavviate la macchina virtuale.
Ora l’installazione partirà correttamente e arriverete alla finestra di selezione delle opzioni internazionali del sitema operativo.
Come prima opzione lasciamo “Language to install”: English (è anche l’unica selezionabile).
Come “Time and currency format”, possiamo impostare Italiano.
Come “Keyboar or input method”, possiamo impostare Italiano (se abbiamo una tastiera italiana naturalmente).

Portiamo a termine i vari passaggi successivi come sempre e abbiamo finito.