Ceci est un petit composant permettant de sauvegarder/charger les propriétés de n'importe quel objet. Les-dites propriétés sont stockées dans un fichier de sérialisation zippé. Les thèmes abordés pour ce code sont principallement la sérialisation, le zippage de fichier avec la librairie SharpZipLib, un peu de flux, la récupération de la liste des nom des propriétés d'un objet ainsi que les valeurs associées à ces propriétés, et l'assignation de valeurs à des propriétés en fonction de leur nom.
Ce code a été compilé avec le Framework SDK 1.1, et à l'aide de l'excélent SharpDevelop. Vous trouverez dans le zip le composant en lui même, ainsi qu'un exécutable de tests.
Tiens mais au fait, à quoi tout celà peut-il bien servir ? Et bien la sauvegarde de propriétés est bien pratique par exemple pour qu'une fenêtre soit replacée au même endroit que lorsqu'elle a été fermée. Si l'utilisateur a laissé la fenêtre en grand avant de quitter, et ien la fenêtre sera de nouveau grande au prochain lancement du prog. Mais bien sûr, tout ceci s'applique aux forms, mais aussi à n'importe quel type d'objet.
Il est à noter que seules les propriétés accessibles en lecture et en écriture, et sérialisables sont sauvegardées.
Source / Exemple :
/*
- Created by SharpDevelop.
- User: Yo
- Date: 03/12/2004
- Time: 22:51
-
- To change this template use Tools | Options | Coding | Edit Standard Headers.
- /
using System;
using System.Drawing;
using System.Windows.Forms;
using System.ComponentModel;
using System.Reflection;
using System.Collections;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization;
using ICSharpCode.SharpZipLib.Zip;
namespace PropertiesKeeperNS{
/// <summary>
/// Permet de stocker et restaurer les propriétés d'un objet, quel qu'il soit. Les propriétés
/// chargées et sauvegardées doivent être accessibles en lecture/écriture, et doivent être
/// sérialisables.
/// </summary>
public class PropertiesKeeper : System.Windows.Forms.Control{
private PropertyAndValueList PropertySaver = new PropertyAndValueList();
private Control m_Ctrl = null;
public Control Ctrl{
set{m_Ctrl = value;}
get{return m_Ctrl;}
}
public PropertiesKeeper(){
}
/// <summary>
/// Permet de charger le fichier de configuration.
/// </summary>
/// <param name="FileName">Le nom du fichier à charger.</param>
public void Load(string FileName){
if(m_Ctrl == null) return;
ZipInputStream zip = new ZipInputStream(new FileStream(FileName,FileMode.Open,FileAccess.Read));
ZipEntry zip_entry;
while((zip_entry = zip.GetNextEntry())!=null){
try{
if(zip_entry.Name == "conf"){
MemoryStream stream = new MemoryStream();
int count;
byte[] mem= new byte[10000];
//l'écriture
while ((count = zip.Read(mem, 0, 10000)) > 0){
stream.Write(mem, 0, count);
}
stream.Seek(0, SeekOrigin.Begin);
LoadConfigFromStream(stream);
}
}catch(Exception e){
Console.WriteLine(e.Message);
}
}
zip.Close();
}
/// <summary>
/// Permet de charger la config depuis un flux.
/// </summary>
/// <param name="stream">Le flux en question.</param>
private void LoadConfigFromStream(Stream stream){
IFormatter formatter = new BinaryFormatter();
PropertySaver = (PropertyAndValueList) formatter.Deserialize(stream);
ApplyProperties();
}
/// <summary>
/// Permet d'appliquer les différentes propriétés à l'objet
/// </summary>
private void ApplyProperties(){
PropertyInfo []properties = m_Ctrl.GetType().GetProperties(BindingFlags.Public|BindingFlags.Instance);
foreach(PropertyInfo p in properties){
if(p.CanRead && p.CanWrite){
Object val = p.GetValue(m_Ctrl, null);
if(val != null){
if(p.PropertyType.IsSerializable){
PropertyAndValue prop = PropertySaver.GetPropertyAndValue(p.Name);
if(prop != null){
p.SetValue(m_Ctrl, prop.PropertyValue, null);
}
}
}
}
}
}
/// <summary>
/// Sauvegarde les différentes propriétés de l'objet, pour peu quelles soient
/// accessibles en lecture et en écriture, et sérialisable.
/// Le fichier de sérialisation est aussi zippé.
/// </summary>
public void Save(string FileName){
if(m_Ctrl == null) return;
PropertySaver.Clear();
// Récupération des propriétés accessibles en lecture/ecriture, et qui sont sérialisables.
PropertyInfo []properties = m_Ctrl.GetType().GetProperties(BindingFlags.Public|BindingFlags.Instance);
foreach(PropertyInfo p in properties){
if(p.CanRead && p.CanWrite){
Object val = p.GetValue(m_Ctrl, null);
if(val != null){
if(p.PropertyType.IsSerializable){
PropertySaver.Add(new PropertyAndValue(p.Name, val));
}
}
}
}
// Sauvegarde des propriétés
MemoryStream myStream = new System.IO.MemoryStream();
IFormatter formatter = new BinaryFormatter();
formatter.Serialize(myStream, PropertySaver);
// Création d'un fichier zip contenant les propriétés
ZipEntry MyZipEntry = new ZipEntry("conf");
ZipOutputStream MyZipOutputStream = new ZipOutputStream((File.Create(FileName)));
MyZipOutputStream.PutNextEntry(MyZipEntry);
byte[] buffer = new byte[4096];
myStream.Seek(0, SeekOrigin.Begin);
int count = myStream.Read(buffer, 0, 4096);
while (count > 0){
MyZipOutputStream.Write(buffer, 0, count);
count = myStream.Read(buffer, 0, 4096);
}
myStream.Close();
MyZipOutputStream.Close();
}
}
[Serializable]
public class PropertyAndValue{
/// <summary>
/// Classe permettant de stocker une propriété avec son nom et sa valeur.
/// </summary>
private string m_PropertyName = String.Empty;
public string PropertyName{
set{m_PropertyName = value;}
get{return m_PropertyName;}
}
private Object m_PropertyValue = null;
public Object PropertyValue{
set{m_PropertyValue = value;}
get{return m_PropertyValue;}
}
public PropertyAndValue(string PropertyName, Object PropertyValue){
m_PropertyName = PropertyName;
m_PropertyValue = PropertyValue;
}
}
[Serializable]
public class PropertyAndValueList : CollectionBase{
/// <summary>
/// Classe permettant de stocker plusieurs propriétés.
/// </summary>
public void Add(PropertyAndValue p){
List.Add(p);
}
public PropertyAndValue GetPropertyAndValue(string propertyName){
foreach(PropertyAndValue p in List){
if(p.PropertyName == propertyName){
return p;
}
}
return null;
}
}
}
Conclusion :
Mes remerciements à Coq qui m'a un peu aidé. Il m'a mis sur une bonne piste pour la récupération des propriétés d'un objet.
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.