L'argomento è molto vario, c'e' chi sottintende con persitenza la possibilità di mantenere il valore di un oggetto per la durata di tutta una sessione di lavoro.
E quindi questo implica che l'oggetto stesso sarà di tipo statico. Il che non implica
nulla di diverso dal modificatore d'accesso "static".
C'e' chi per persitenza intende il salvataggio fisico del Dato su db, ma questo implica
che il tipo stesso sarà un entity e probabilmente ha vita e logica direttamente legate
al db stesso.
Quindi quali di questi sostenitori hanno ragione? In parte entrambi, in parte nessuno,
perchè entrambe le definizioni sono carenti o meglio incomplete.
Un oggetto persistente è un classe, che "dopo l'utilizzo", "dopo la distruzione", "dopo aver chiuso e riaperto la nostra applicazione" ripresenta i dati.
Qui qualcuno potrebbe dire Bella scoperta li pre imposto by Default, già ma questa non è persistenza è pre impostazione.
Partiamo quindi con un esempietto che ci permetterà di meglio comprendere la situazione:
public class UserDefinitions
{
private string _Alias;
public string Name { get; set; }
public string Surname { get; set; }
public string Alias
{
get { return _Alias; }
set { _Alias = value; }
}
public DateTime LastAccess { get; set; }
}
Si tratta di un oggetto più o meno semplice, il cui scopo è "mantenere" vive le informazioni di un utente.
Non è difficile notare che ho già fatto in modo che la property Alias già nasconda il field _Alias. Ci servirà per l'esempio.
Così come ci servirà nell'esempio anche quanto già scrissi per la serializzazione ..
public static class XmlDeSerializerTool
{
public static void Serialize<T>(string fileName, T elements)
{
TextWriter tw = new StreamWriter(fileName);
XmlSerializer xmls = new XmlSerializer(typeof(T));
xmls.Serialize(tw, elements);
tw.Close();
tw = null;
xmls = null;
}
public static T Deserialize<T>(string fileName)
{
Type e = typeof(T);
T elements = (T)Activator.CreateInstance(e);
TextReader tr = new StreamReader(fileName);
XmlSerializer xmls = new XmlSerializer(typeof(T));
elements = (T)xmls.Deserialize(tr);
tr.Close();
tr = null;
xmls = null;
return elements;
}
}
Che "come al solito riciclo per questioni di comodità".
Quindi la nostra classe assume un aspetto più interessante, implementado un evento, direttamente da component model.
public class UserDefinitions :System.ComponentModel.INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
private string _Alias;
public string Name { get; set; }
public string Surname { get; set; }
public string Alias
{
get { return _Alias; }
set {
_Alias = value;
if (PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs("Alias"));
}
}
}
public DateTime LastAccess { get; set; }
}
Questo per definizione ha già la possibilità di indicare quale proprietà è cambiata.
Una breve precisazione, utilizzando il mio DE/SErializzatore non è necessario implementare il costruttore, ne gli attributi necessari per la serializzazione, ma questo lo si deve in parte a XmlSerializer.
A questo punto creiamo un caso di test.
static void Main(string[] args)
{
UserDefinitions ud = new UserDefinitions();
if (File.Exists(@"c:\myData.xml"))
{
ud = XmlDeSerializerTool.Deserialize<UserDefinitions>(@"c:\myData.xml");
}
else
{
ud.Name = "Fabio";
ud.Surname = "Arosio";
ud.Alias = "TheMa!";
}
ud.PropertyChanged += new PropertyChangedEventHandler(us_PropertyChanged);
ud.LastAccess = DateTime.Now;
}
e qui il delegato per la gestione della propertyChange
public class UserDefinitions :System.ComponentModel.INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
private string _Alias;
public string Name { get; set; }
public string Surname { get; set; }
public string Alias
{
get { return _Alias; }
set {
_Alias = value;
if (PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs("Alias"));
}
}
}
public DateTime LastAccess { get; set; }
}
Di concetto questo caso ha poco valore, se non pochissimo, ma mi è servito per salvare il file xml e per mostrarne il contenuto.
<?xml version="1.0" encoding="utf-8"?>
<UserDefinitions
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Name>Fabio</Name>
<Surname>Arosio</Surname>
<Alias>TheMa!</Alias>
<LastAccess>
2011-08-26T15:18:34.1125638+02:00
</LastAccess>
</UserDefinitions>
E bene questa è la nostra "persistenza".
Attenzione non stiamo parlando di soli dati, ma anche della struttura del dato, non del singolo valore.
Di contro questo concetto sembra molto complesso, anche se secondo me, i dubbi nascono su che cosa realmente deve essere inteso come "persistente", e non tanto su come deve
avvenire la persistenza.
Nessun commento:
Posta un commento