Difficoltà:
Piattaforma: C#.

Il loro principale utilizzo è quello di estendere i metodi di una classe quando non è possibile utilizzare l’ereditarietà, quando non si ha il codice sorgente o quando semplicemente, si vogliono aggiungere metodi senza dover modificare la classe originale.
Gli Extension method vengono dichiarati come metodi statici di classi esterne statiche, e vengono riconosciuti dall’Intellisense come metodi interni alla classe.

In C# la dichiarazione di un Extended Method è quindi simile a quella di un metodo statico, fatta eccezione per il primo parametro del metodo che è composto dalla parola chiave this e dal nome del tipo da estendere.

Sebbene a prima vista la differenza che c’è tra un Extension method ed un normale metodo di classe sembra molto poca, in realtà gli utilizzi che se ne possono fare sono diversi, basti pensare ad esempio che gli Extension method vengono usati dalla classe Enumerable di  Linq per estendere l’interfaccia generica IEnumerable 

Pur essendo dei metodi statici di classe, questi appaiono come metodi dell’istanza ma non possono però accedere alle variabili private interne all’istanza.
Inoltre, al contrario dell’ereditarietà in cui è possibile fare l’ovverride di un metodo della classe parent, nel caso degli extension method, se la classe base e la classe che estende hanno un metodo con stessa firma, allora verrà eseguito automaticamente il metodo della classe base. E’ invece consentito l’overload.  

Vediamo ora un esempio e creiamo la classe da estendere UserClass:

    public class UserClass
    {
        private string m_Name;
        private string m_Surname;
        private Int16 m_Age;

        public UserClass()
        {
            this.m_Name = “”;
            this.m_Surname = “”;
            this.m_Age = 10;
        }
        public string Name
        {
            get
            {
                return m_Name;
            }
            set
            {
                m_Name = value;
            }
        }

        public string Surname
        {
            get
            {
                return m_Surname;
            }
            set
            {
                m_Surname = value;
            }
        }

        public Int16 Age
        {
            get
            {
                return m_Age;
            }
            set
            {
                m_Age = value;
            }
        }

Ora creiamo la classe UserClassExtension che estenderà la prima:

    public static class UserClassExtension
    {
        public static Boolean IsAdult(this UserClass user)
        {
            if (user.Age >= 18)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }

Qui è visibile l’unico metodo IsAdult che vuole come unico parametro un istanza del tipo da estendere.

A questo punto possiamo andare ad istanziare un oggetto del tipo UserClass e possiamo vedere: sia come l’intellisense riconosce il metodo come se fosse effettiva parte integrante della classe, sia come il metodo statico venga effettivamente eseguito sull’istanza corrente.

            UserClass User = new UserClass();
            User.Name = “Jon”;
            User.Surname = “Doe”;
            User.Age = 18;
             
            if (User.IsAdult())
            {MessageBox.Show(“Adult”);}
            else
            { MessageBox.Show(“Child”); }

Possiamo notare inoltre che il metodo non richiede nessun parametro in ingresso, infatti il primo parametro che è quello che identifica l’istanza, viene omesso.

Per testare come si comporta un Extension Method nel caso in cui il metodo esista già, facciamo un altro esempio.

Creiamo una classe Sealed UserFinalClass che ha già un metodo IsAdult

   public sealed class UserFinalClass
    {
        private string m_Name;
        private string m_Surname;
        private Int16 m_Age;

        public UserFinalClass()
        {
            this.m_Name = “”;
            this.m_Surname = “”;
            this.m_Age = 9;
        }
     
     …
     …
     
        public bool IsAdult()
        {
            if (this.m_Age >= 18)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }

 Creaiamo ora la classe che la estenderà:

  public static class UserFinalClassExtension
    {
        public static Boolean IsAdult(this UserFinalClass user)
        {
            if (user.Age >= 16)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public static Boolean IsTeenAger(this UserFinalClass user)
        {
            if ((user.Age >= 13) && (user.Age <= 19))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

    }

In questo caso,  eseguendo il codice seguente, possiamo notare che per metodo IsAdult verrà chiamato quello definito nella classe base mentre per il metodo IsTeenAger verrà chiamato l’Extension method.

            UserFinalClass UserFinal = new UserFinalClass();
            UserFinal.Name = “Jon”;
            UserFinal.Surname = “Doe”;
            UserFinal.Age = 16;

            if (UserFinal.IsAdult())
            { MessageBox.Show(“Adult”); }
            else
            { MessageBox.Show(“Child”); }

            if (UserFinal.IsTeenAger())
            { MessageBox.Show(“Teenager”); }
            else
            { MessageBox.Show(“I’m not a teenager”); }

In conclusione, abbiamo visto come usando gli Extension method è possibile  crearsi librerie esterne che estendono classi esistenti, ad esembio le classi basi del framework. Potete trovare qualche metodo utile su questo link.

Alla prossima

Difficoltà:
Piattaforma: VB.NET

Come prima cosa definiamo brevemente  che cos’è un Design pattern.

Un Pattern è un modello o un schema,  e  in campo informatico,  in particolare nella programmazione Object Oriented, si parla di Design pattern,  per descrivere soluzioni progettuali  generalizzate applicabili a determinati  tipi di problemi ricorrenti o che si possono verificare in diverse situazioni.

Un design pattern è quindi caratterizzato da: un nome che generalmente ne richiama il comportamento, da una descrizione di un problema o contesto generico cui può essere applicato  e da una descrizione generalizzata della soluzione che verrà applicata.

In futuro su questo blog approfondirò di più l’argomento.

Lazy Inizialization

Questo pattern è utilizzato principalmente quando è necessario effettuare operazioni di lettura dati particolarmente  time consuming o impegnative.  Un esempio potrebbe essere la lettura di dati di inizializzazione da un database.
Queste verranno eseguite solo quando effettivamente sono necessarie e da qui ne deriva il nome  “Inizializzazione Pigra”

Come dicevo l’implementazione è estremamente semplice e prevede l’utilizzo di un flag interno usato per tracciare se i dati sono già stati effettivamente caricati.

Public Class LazyInitializerClass
    Private m_DataInizialized As Boolean
    Private m_DataToRead As String
    Public Sub New()
        m_DataInizialized = False
        ‘ reset Data
        m_DataToRead = “”
    End Sub
    Public ReadOnly Property MyData() As String
        Get
            If Not m_DataInizialized Then Initialize()
            Return m_DataToRead
        End Get
    End Property
    Private Sub Initialize()
        m_DataInizialized = True
        ‘ read Data
        m_DataToRead = “Data From Database”
    End Sub
    Public Sub Refresh()
        m_DataInizialized = False
    End Sub
End Class

Inizialmente, quando l’oggetto viene creato, il flag viene impostato a false. Successivamente quando la property viene chiamata per la prima volta, i dati vengono letti ed il flag di controllo viene impostato a true.
Tutte le interrogazioni successive della property  invece,  non leggeranno più la sorgente dei dati, ma ne restituiranno direttamente il contenuto precedentemente letto.

In questo esempio ho aggiunto  il metodo di refresh che ci permetta di ricaricare i dati dal DB.

Pattern IsDirty

Questo pattern è di natura simile  al precedente, ed è principalmente utilizzato per ottimizzare  operazioni di salvataggio di un determinato oggetto, ovvero queste ultime verranno eseguite solo quando sono state fatte effettivamente delle modifiche all’oggetto.
Anche qui il principio è molto semplice e si basa sull’utilizzo di un flag interno che viene impostato a true tutte le volte che una property cambia.

Public Class IsDirtyClass
    Private m_IsDirty As Boolean
    Private m_MyData As String
    Public Property MyData() As String
        Get
            Return m_MyData
        End Get
        Set(ByVal value As String)
            m_IsDirty = True
            m_MyData = value
        End Set
    End Property
    Public Sub New()
        m_IsDirty = False
        ‘ reset Data
        m_MyData = “”
    End Sub
    Public Sub Save()
        If m_IsDirty Then
            ‘ Save Data
            m_IsDirty = False
        End If
    End Sub
end Class

Il metodo che effettua il salvataggio verificherà quindi che almeno una property è cambiata,  in caso contrario non effettuerà nessuna operazione l’inutile .

Singleton

Questo pattern si discosta leggermente dai primi due poiché, sebbene utilizzi un principio di Lazy iniziatialization, la sua caratteristica principale è quella di assicurarsi che esita una sola istanza attiva di una data classe.
E’ un pattern molto usato a volte eccessivamente  o impropriamente  applicato e da qui anche la fama, a mio avviso ingiustificata,  di essere anche un anti pattern. Sebbene molto semplice nell’implementazione vale la pena spendere due parole in più.
Singleton è un cosi detto pattern creazionale, ovvero fa parte della famiglia di quei patterns  che,  modificando l’approccio standard alla  creazione delle proprie istanze, (in questo caso rendendo privato il costruttore),  nascondono al client le modalità in cui vengono create le istanze stesse.

I real case  dove più è utilizzato sono i casi in cui è necessario centralizzare il controllo di uno o più processi su singolo oggetto,  dove è necessario fornire un unico punto di accesso condiviso a determinate risorse o infine, in contesti di load balancing.

Il principio di funzionamento è molto semplice, l’istanza viene creata la prima volta che si accede alla variabile  e non all’avvio del programma.
Tutte le volte che viene richiesta una nuova istanza, viene fornito il riferimento all’istanza esistente.

Per far questo viene dichiarato nella classe un oggetto interno privato dello stesso tipo della classe
Viene poi mascherato  il costruttore mentre la creazione della prima istanza o la restituzione del riferimento all’istanza esistente viene fatta attraverso un metodo statico.

 Public Class SingleTonClass
    Private Shared m_instance As SingleTonClass
    Protected Sub New()
    End Sub
    Public Shared Function GetInstance() As SingleTonClass
        If m_instance Is Nothing Then
            m_instance = New SingleTonClass
        End If
        Return m_instance
    End Function
End Class

E’ importante ricordare che nel caso ci siano più client o thread che istanziano questa classe,  è necessario, anche se il framework .NET ci viene già incontro,  governarne l’accesso concorrente ai dati con dei lock.

Difficoltà:
Piattaforma: VB.NET 

Se stiamo lavorando con tipi di dati valore,  è possibile effettuare paragoni attraverso l’utilizzo dei classici operatori di confronto  maggiore (>), minore (<)  = e uguale (=).
Anche per i tipi stringa è possibile usare tali operatori, anche se in questo caso , l’ordinamento può essere condizionato da opzioni di “Option Compare”  o  dalle impostazioni internazionali.

Ma cosa succede se abbiamo bisogno di confrontare degli oggetti?
Il Framework .NET ci mette a disposizione l’interfaccia IComparable. Attraverso l’implementazione di questa interfaccia, e più precisamente dell’ unico metodo compareTo(Object) è possibile comunicare al metodo chiamante,  se il nostro oggetto è maggiore o meno rispetto ad un secondo oggetto passato come parametro.

Mentre i valori numerici, le stringhe e le date hanno già il metodo CompareTo, per le nostre classi  è necessario implementarla manualmente. 
Verificandone l’implementazione negli oggetti contentuti, classi come Arraylist sono in grado, chiamando automaticamente il metodo CompareTo,  di restituire elenchi ordinati.

Possiamo verificarlo creando ad esempio una lista di stringhe e chiamando successivamente il metodo Sort di un ArrayList.

Dim Product1 As String
Dim Product2 As String
Dim Product3 As String
Dim Product4 As String

Dim sSortedObject As String = “”

Try
    Product1 = “Parallelepiped 1″
    Product2 = “Parallelepiped 2″
    Product3 = “Parallelepiped 3″
    Product4 = “Parallelepiped 4″

    Dim myList As New ArrayList

    myList.Add(Product4)
    myList.Add(Product1)
    myList.Add(Product2)
    myList.Add(Product3)

    myList.Sort()

    For Each obj In myList
        sSortedObject &= obj & vbCrLf
    Next

    MessageBox.Show(sSortedObject)
Catch ex As Exception
    MessageBox.Show(ex.Message)
End Try

Nel caso in cui il nostro Arraylist contenga un elenco di oggetti non confrontabili, il metodo Sort ci restituisce un errore.

Dim Product1 As ProductClass                               
Dim Product2 As ProductClass                               
Dim Product3 As ProductClass                               
Dim Product4 As ProductClass                               
                                                           
Dim sSortedObject As String = “”                           
                                                           
Try                                                        
    Product1 = New ProductClass(5, 5, 5, “Parallelepiped 1″)
    Product2 = New ProductClass(6, 6, 6, “Parallelepiped 2″)
    Product3 = New ProductClass(3, 4, 5, “Parallelepiped 3″)
    Product4 = New ProductClass(6, 6, 2, “Parallelepiped 4″)
                                                        
    Dim myList As New ArrayList                             
                                                        
    myList.Add(Product1)                                    
    myList.Add(Product2)                                    
    myList.Add(Product3)                                    
    myList.Add(Product4)                                  
                                                        
    myList.Sort()                                           
                                                        
    For Each obj In myList                                  
        sSortedObject &= obj.Name & vbCrLf                  
    Next                                                    
                                                        
    MessageBox.Show(sSortedObject)                         
Catch ex As Exception                                       
    MessageBox.Show(ex.Message & ex.InnerException.Message)
End Try 

(Non ho implemento qui la classe ProductClass per motivi di praticità, in ogni caso verrà rivista più avanti.)

Implementare il metodo CompareTo

Questo metodo prevede la restituzione di un valore minore di zero nel caso in cui l’oggetto è più piccolo di quello passato come parametro, di zero nel caso in cui siano uguali e maggiore di zero nel caso in cui sia più grande.

Creiamo una classe che implementa l’interfaccia IComparable

Public Class ProductClassComparable
    Implements IComparable

    Private m_height As Integer
    Private m_width As Integer
    Private m_length As Integer

    Private m_Name As String

    Public Sub New()
        m_height = 0
        m_width = 0
        m_length = 0
    End Sub
    Public Sub New(ByVal iHeight As Integer, ByVal iWidth As Integer, ByVal iLength As Integer, ByVal sName As String)
        m_height = iHeight
        m_width = iWidth
        m_length = iLength
        m_Name = sName
    End Sub

    Public Property Height() As Integer
        Get
            Return m_height
        End Get
        Set(ByVal value As Integer)
            m_height = value
        End Set
    End Property
    Public Property Width() As Integer
        Get
            Return m_width
        End Get
        Set(ByVal value As Integer)
            m_width = value
        End Set
    End Property

    Public Property Length() As Integer
        Get
            Return m_length
        End Get
        Set(ByVal value As Integer)
            m_length = value
        End Set
    End Property

    Public Property Name() As String
        Get
            Return m_Name
        End Get
        Set(ByVal value As String)
            m_Name = value
        End Set
    End Property

    Public ReadOnly Property GetVolume() As Decimal
        Get
            Return (m_height * m_length * m_width)
        End Get
    End Property

    Public Function CompareTo(ByVal obj As Object) As Integer Implements System.IComparable.CompareTo
        If Me.Name < obj.Name Then
            Return -1
        ElseIf Me.Name > obj.Name Then
            Return 1
        Else
            Return 0
        End If
    End Function

End Class

Il metodo principale qui è CompareTo(Object) dove viene effettuato il confronto vero e proprio e viene restituito il risultato.
E’ importante notare che all’interno di questo metodo possiamo implementare il tipo di controllo che ci serve, ad esempio un operazione, il confronto sul numero di caratteri etc, ma un vincolo di questa soluzione è il fatto che stiamo definendo una regola precisa di confronto tra oggetti, e quindi, nel caso di qualsiasi futuro ordinamento, siamo vincolati a questa regola.
Dato inoltre che non stiamo lavorando con un ArrayList di generici, è inoltre consigliato aggiungere gli opportuni controlli sul tipo di oggetto passato come parametro. 

Ordinare utilizzando un oggetto IComparer

Una soluzione alternativa è quella di andare a creare una classe che implementi l’interfaccia IComparer e che si occupi di effettuare il confronto tra i due oggetti. Un’istanza di questa classe verrà passata come parametro al metodo Sort dell’ArrayList.

Analogamente al metodo CompareTo, anche il metodo Compare restituisce in Int32 che dice al chiamante se il primo oggetto è maggiore o minore del secondo oggetto.

Public Class ComparerProductClass
    Implements IComparer
    Public Sub New()
        MyBase.New()
    End Sub
    Public Function Compare(ByVal x As Object, ByVal y As Object) As Integer Implements        System.Collections.IComparer.Compare

     ‘ … Implementazione del codice di confronto tra gli oggetti
    End Function
End Class

Generalizzare il nostro oggetto Comparer

Con un po’ di reflection e un paio di property in più possiamo costruire una classe comparer che ci permetta di generalizzare il nome della property su cui effettuare il confronto oltre al verso dell’ordinamento.

Imports System.Reflection
Public Class ComparerGeneralizedClass
    Implements IComparer

    Private m_propertyname As String
    Private m_ascending As Boolean

    ‘ Costruttore
    Public Sub New(ByVal PropertyName As String, ByVal Ascending As Boolean)
        m_propertyname = PropertyName
        m_ascending = Ascending
    End Sub

    Public Function Compare(ByVal obj1 As Object, ByVal obj2 As Object) As Integer Implements System.Collections.IComparer.Compare
        Dim iResult As Integer

        Dim Type_obj1 As Type
        Dim Type_obj2 As Type

        Dim PropertyInfo_obj1 As PropertyInfo
        Dim PropertyInfo_obj2 As PropertyInfo

        Dim Valueobj1 As IComparable
        Dim Valueobj2 As IComparable

        Type_obj1 = obj1.GetType()
        Type_obj2 = obj2.GetType()

        ‘ Verificare che la Property Esista
        PropertyInfo_obj1 = Type_obj1.GetProperty(m_propertyname)
        PropertyInfo_obj2 = Type_obj2.GetProperty(m_propertyname)

        If PropertyInfo_obj1 Is Nothing Then
            ‘ Property  non Esiste
            Throw New Exception(“Property ” & m_propertyname & ” doesn’t Exist”)
        End If
        If PropertyInfo_obj2 Is Nothing Then
            ‘ Property  non Esiste
            Throw New Exception(“Property ” & m_propertyname & ” doesn’t Exist”)
        End If

        Valueobj1 = PropertyInfo_obj1.GetValue(obj1, Nothing)
        Valueobj2 = PropertyInfo_obj2.GetValue(obj2, Nothing)

        If Valueobj1 Is Nothing Then
            ‘ Property  non IComparable
            Throw New Exception(“Property ” & m_propertyname & ” is not IComparable”)
        End If
        If Valueobj2 Is Nothing Then
            ‘ Property  non IComparable
            Throw New Exception(“Property ” & m_propertyname & ” is not IComparable”)
        End If

        iResult = Valueobj1.CompareTo(Valueobj2)

        If iResult <> 0 Then
            If m_ascending Then
                Return iResult
            Else
                Return (-iResult)
            End If
        End If

        Return 0
    End Function
End Class

Vediamone a questo punto il codice.
Come prima cosa abbiamo aggiunto due property, la prima di tipo String, dove andiamo ad inserire il nome della property su cui vogliamo effettuare l’ordinamento, mentre la seconda di tipo Boolean, ci serve per capire se vogliamo fare un ordinamento dal più piccolo al più grande o viceversa.
Nel costruttore obblighiamo l’inserimento di questi due parametri

Public Sub New(ByVal PropertyName As String, ByVal Ascending As Boolean)

Nel metodo Compare invece, come prima cosa andiamo a recuperare il tipo degli oggetti

Type_obj1 = obj1.GetType()
Type_obj2 = obj2.GetType()

e successivamente, recuperiamo i due oggetti PropertyInfo della property desiderata attraverso i due oggetti Type appena istanziati.

PropertyInfo_obj1 = Type_obj1.GetProperty(m_propertyname)
PropertyInfo_obj2 = Type_obj2.GetProperty(m_propertyname)

A questo punto se uno dei due oggetti propertyInfo e a nothing vuol dire che la proprietà non esiste. (Attenzione al case sensitive)
Proseguendo, andiamo a leggerne il valore e ad assegnarlo a due oggetti di tipo IComparable.

Valueobj1 = PropertyInfo_obj1.GetValue(obj1, Nothing)
Valueobj2 = PropertyInfo_obj2.GetValue(obj2, Nothing)

Qui è importante ricordare che numerici, stringhe e date sono già ICompareble quindi assumiamo che la nostra property sia di questo tipo o sia un oggetto che comunque implementa l’interfaccia IComparable.
Nel caso effettuiamo un controllo e se così’ non fosse, solleviamo un eccezione.

If Valueobj1 Is Nothing Then
    ’ Property  non IComparable
    Throw New Exception(“Property ” & m_propertyname & ” is not IComparable”)
End If

Il resto è semplice, usiamo il metodo CompareTo per capire quale dei due oggetti è il maggiore e la property Ascending per decidere se invertire o meno il risultato.

Di seguito possiamo vederne il risultato:

Dim myList As New ArrayList

myList.Add(Product4)
myList.Add(Product1)
myList.Add(Product2)
myList.Add(Product3)

sSortedObject = “”
myComparer = New ComparerGeneralizedClass(“Name”, True)

myList.Sort(MyComparer)
For Each obj In myList
    sSortedObject &= obj.Name & vbCrLf
Next
MessageBox.Show(sSortedObject)

sSortedObject = “”
myComparer = New ComparerGeneralizedClass(“Name”, False)
myList.Sort(myComparer)
For Each obj In myList
    sSortedObject &= obj.Name & vbCrLf
Next
MessageBox.Show(sSortedObject)

‘ Volume
sSortedObject = “”
myComparer = New ComparerGeneralizedClass(“GetVolume”, False)
myList.Sort(myComparer)
For Each obj In myList
    sSortedObject &= obj.Name & ” Volume:” & obj.GetVolume.ToString & vbCrLf
Next
MessageBox.Show(sSortedObject)

In conclusione

Anche in questo caso è possibile apportare diverse migliorie alla nostra classe e soprattutto renderla un pochino più solida aggiungendo qualche controllo in più.

In ogni caso abbiamo costruito un semplice prototipo riutilizzabile  che ci permette di ordinare i nostri oggetti potendo scegliere nome della property ed il verso di ordinamento.

Al prossimo post.

Difficoltà:
Piattaforma: VB.NET 

Durante lo sviluppo di alcune applicazioni, mi è capitato di dover creare istanze  che fossero copie esatte di un oggetto esistente.  Poiché  le classi non sono dei tipi valore, ovvero non ereditano dalla classe System.ValueType, ma le loro istanze sono in realtà dei riferimenti all’oggetto,   le operazioni di assegnazione, non creano un duplicato dell’oggetto, ma bensì del riferimento.
In questo post esploriamo due possibili modi per implementare un meccanismo  di clonazione degli oggetti in . NET. 

Due parole sulla clonazione

Con clonazione si intende una copia esatta di un oggetto.  Mentre per i tipi valore e per le structure è possibile ottenere questo risultato attraverso una semplice assegnazione,  per duplicare un oggetto è necessario crearne una nuova istanza ed effettuare la copia di tutti i suoi attributi. 

Un modo semplice, (ma non matematico) che possiamo usare  per capire se due istanze di  oggetti si stanno riferendo allo stesso dato o a due dati differenti,   è andare per esempio a confrontare  il codice Hash.

MyObject.GetHashCode()

(attenzione, il codice Intero di Hash restituito dalla classe base Object non assicura l’univocità)

Clonazione attraverso l’utilizzo di MemberWiseClone

Questo approccio prevedere l’implementazione da parte della nostra classe dell’interfaccia iCloneable. Questa interfaccia richiede che venga implementato un unico metodo Clone che restituisce un nuovo oggetto.
All’interno del metodo Clone chiameremo il metodo protetto di system.Object MemberWiseClone che crea una copia di tutti i riferimenti dell’oggetto.

In questo esempio molto semplice definiamo una classe ClonableAnimal come segue:

Public Enum Species
    Dog
    Cat
    Bird
End Enum
 
Public Class ClonableAnimal
  Implements ICloneable

Private m_Age As Integer
Private m_Name As String
Private m_AnimalType As Species
Public ReadOnly Property Age() As Integer
   Get
      Return m_Age
   End Get
End Property
Public Property Name() As String
   Get
      Return m_Name
   End Get
   Set(ByVal value As String)
      m_Name = value
   End Set
End Property
Public ReadOnly Property AnimalType() As Species
   Get
      Return m_AnimalType
   End Get
End Property
 
Public Sub New(ByVal NewName As String, ByVal NewAnimalType As Species)
   m_Age = 0
   m_Name = NewName
   m_AnimalType = NewAnimalType
End Sub
Public Sub Addyear()
   m_Age = m_Age + 1
End Sub
Public Function Clone() As Object Implements System.ICloneable.Clone
   Return Me.MemberwiseClone
End Function
Public Function GetDescription() As String
   Return “MyName is: ” & m_Name & “, My age is:” & m_Age.ToString & ” and I am a ” & m_AnimalType.ToString
End Function

Questa classe è composta di: tre semplici property, un metodo clone che restituisce una nuova istanza dell’oggetto, un metodo Addyear() usato per incrementare la property Age, ed un metodo GetDescription() che restituisce il contenuto delle property dell’oggetto.

A questo punto testiamo il metodo clone creando un oggetto MyAnimal1 ed assegnando a MyAnimal2 il valore restituito dal metodo Clone.

Dim MyAnimal1 As ClonableAnima)
Dim MyAnimal2 As ClonableAnimal
MyAnimal1 = New ClonableAnimal(“Scooby Doo”, Species.Dog)
MyAnimal1.Addyear()
MyAnimal1.Addyear()
MyAnimal2 = MyAnimal1.Clone

Il risultato è effettivamente una copia esatta dell’oggetto poichè le property sono le stesse ma il codice Hash differisce.

Considerando che molte classi in NET espongono già un metodo Clone, questo approccio sembrerebbe a prima vista il più semplice da implementare.
E’ necessario però fare una considerazione, il metodo MemberWiseClone crea una copia dei riferimenti, questo vuol dire che nel caso in cui il nostro oggetto ha attributi di tipo valore, questi verranno correttamente duplicati, ma se uno o più dei sui attributi è sua volta un oggetto, allora di questi ne verrà copiato il riferimento.

Prendiamo ad esempio la nuova classe:

Public Class ClonableMaster
   Implements ICloneable
Private m_Name As String
Private m_Pet As ClonableAnimal
Public Property Name() As String
   Get
      Return m_Name
   End Get
   Set(ByVal value As String)
      m_Name = value
   End Set
End Property
Public Property Pet() As ClonableAnimal
   Get
      Return m_Pet
   End Get
   Set(ByVal value As ClonableAnimal)
      m_Pet = value
   End Set
End Property
Public Sub New(ByVal HumanName As String, ByVal NewName As String, ByVal NewAnimalType As Species)
   m_Name = HumanName
   m_Pet = New ClonableAnimal(NewName, NewAnimalType)
End Sub
Public Function Clone() As Object Implements System.ICloneable.Clone
   Return Me.MemberwiseClone
End Function
End Class

Anche questa classe implementa l’interfaccia iClonable, ma una delle sue property, la Pet, è di tipo ClonableAnimal.
Nell’esempio che segue effettuiamo la clonazione sull’oggetto principale ed andando poi a verificare il risultato, possiamo vedere che, mentre gli attributi valore degli oggetti MyHuman1 e MyHuman2 sono stati copiati, la property Pet dei due oggetti punta allo stesso dato.

Dim MyHuman1 As ClonableMaster
Dim MyHuman2 As ClonableMaster
MyHuman1 = New ClonableMaster(“Shaggy”, “Scooby Doo”, Species.Dog)
MyHuman1.Pet.Addyear()
MyHuman1.Pet.Addyear()
‘ cloniamo l’oggetto
MyHuman2 = MyHuman1.Clone

‘ cambiamo la property name dell’oggetto incorporato Pet e ne incrementiamo la Age.
MyHuman1.Pet.Name = “Scooby Doo 2″
MyHuman1.Pet.Addyear()
MyHuman1.Pet.Addyear()

A questo punto possiamo verificare che in entrambe le istanze la property Pet è variata e che il codice Hash è lo stesso

Clonazione attraverso la serializzazione

Un’altra possibile soluzione prevede l’utilizzo della serializzazione dell’oggetto per poterne creare una copia esatta, ovvero in una prima fase viene fatta la trasformazione dell’oggetto in uno stream di bytes, e subito dopo viene fatta la deserializzazione in una nuova istanza di oggetto.

Sebbene questa tecnica permetta la clonazione di oggetti che non espongono nessun metodo clone, è però necessario che l’oggetto stesso e tutti i suoi attributi siano serializzabili.
E’ importante sottolineare che per essere serializzabile, una classe deve essere marcata con l’attributo Serializable, e che le sue eventuali classi padre siano serializzabili.

Per verificarne il funzionamento creiamo le seguenti due classi :

<Serializable()> _
Public Class SerializableAnimal
Private m_Age As Integer
Private m_Name As String
Private m_AnimalType As Species
Public ReadOnly Property Age() As Integer
   Get
      Return m_Age
   End Get
End Property
Public Property Name() As String
   Get
      Return m_Name
   End Get
   Set(ByVal value As String)
      m_Name = value
   End Set
End Property
Public ReadOnly Property AnimalType() As Species
   Get
      Return m_AnimalType
   End Get
End Property
Public Sub New(ByVal NewName As String, ByVal NewAnimalType As Species)
   m_Age = 0
   m_Name = NewName
   m_AnimalType = NewAnimalType
End Sub
Public Sub Addyear()
   m_Age = m_Age + 1
End Sub
Public Function GetDescription() As String
   Return “MyName is: ” & m_Name & “, My age is: ” & m_Age.ToString & ” and I am a ” & m_AnimalType.ToString
End Function
End Class

Questa classe è identica alla precedente tranne che per il fatto che non implementa iCloneable ed è marcata serializable

Imports System.Runtime.Serialization.Formatters.Binary
<Serializable()> _
Public Class SerializableMaster
   Implements ICloneable
Private m_Name As String
Private m_Pet As SerializableAnimal
Public Property Name() As String
   Get
      Return m_Name
   End Get
   Set(ByVal value As String)
      m_Name = value
   End Set
End Property
Public Property Pet() As SerializableAnimal
   Get
      Return m_Pet
   End Get
   Set(ByVal value As SerializableAnimal)
      m_Pet = value
   End Set
End Property
Public Sub New(ByVal HumanName As String, ByVal NewName As String, ByVal NewAnimalType As Species)
   m_Name = HumanName
   m_Pet = New SerializableAnimal(NewName, NewAnimalType)
End Sub
Public Function Clone() As Object Implements System.ICloneable.Clone
   Dim Formatter As New BinaryFormatter
   Dim objMemorystrem As New System.IO.MemoryStream
   Formatter.Serialize(objMemorystrem, Me)
   objMemorystrem.Position = 0
   Return Formatter.Deserialize(objMemorystrem)
End Function
End Class

In questo caso le differenze sono date dall’attributo <Serializable()>, dall’utilizzo del namespace System.Runtime.Serialization.Formatters.Binary e dal metodo Clone.

Al contrario del metodo precedente, la clonazione per serializzazione permette la clonazione anche di attributi oggetto.

Dim MyHuman1 As SerializableMaster
Dim MyHuman2 As SerializableMaster
MyHuman1 = New SerializableMaster(“Shaggy”, “Scooby Doo”, Species.Dog)
MyHuman1.Pet.Addyear()
MyHuman1.Pet.Addyear()
‘ Cloniamo l’oggetto
MyHuman2 = MyHuman1.Clone
‘ cambiamo la property name dell’oggetto incorporato Pet e ne incrementiamo la Age.

MyHuman1.Pet.Name = “Scooby Doo 2″
MyHuman1.Pet.Addyear()
MyHuman1.Pet.Addyear()

In questo caso le modifiche post clonazione hanno riguardato solo uno dei due oggetti.

In Conclusione

Abbiamo visto due possibili approcci all’implementazione di un sistema di clonazione. Entrambe le soluzione presentano pregi e difetti, quindi può non essere del tutto corretto preferire a priori un metodo piuttosto che l’altro.

Va inoltre considerato che questo è solo uno spunto, ed entrambe le soluzione possono essere largamente migliorate.

Per esempio per quanto riguarda la clonazione attraverso MemberwiseClone, un ulteriore passo può essere quello di utilizzare la reflection per scorrere all’interno del metodo clone i vari field dell’oggetto, testare se sono iCloneable e nel caso, chiamare ricorsivamente il metodo clone.

Per quanto riguarda la soluzione che utilizza la serializzazione invece, andrebbe previsto l’inserimento di un controllo che verifichi che l’oggetto sia effettivamente serializzabile.

Al prossimo post.

Questo blog nasce dal desiderio di condividere la propria esperienza, dalla passione per il proprio lavoro, e sicuramente e non ultima, dalla voglia di potersi confrontare.

Una definizione che ho trovato in rete e che mi piace molto è questa:
“I blog sono un modo estremamente dinamico e veloce per entrare nelle discussioni degli utenti, fornire suggerimenti e consigli e ricevere feedback.”

Si ma di cosa parlerà?
Mi piace l’idea di non pormi dei vincoli, parleremo di ciò che ruota intorno al mondo della programmazione, idee e spunti tecnici, ma anche metodologie, approcci alla risoluzione dei problemi e qualche volta spero mi concediate anche qualche divagazione.

e allora via, ci vediamo al prossimo post.