Sauvegarde/chargement de propriétés d'un objet

Soyez le premier à donner votre avis sur cette source.

Vue 10 905 fois - Téléchargée 507 fois

Description

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.

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
167
Date d'inscription
dimanche 6 février 2005
Statut
Membre
Dernière intervention
13 avril 2007

Code très sympatique et bien mieux que le mien qui était basé sur le même thème... grrrr lol Ca fait également plaisir de voir que tu as utilisé SharpDevelop ; c'est un très bon IDE, il faut le soutenir !! (la sharpdevelop2 est vraiment bien également)
Je vais essayer d'intégrer ta source à un de mes projets et te ferait un retour si il y a des choses intéressantes à dire ;-)
Messages postés
305
Date d'inscription
lundi 7 janvier 2002
Statut
Membre
Dernière intervention
10 août 2011
4
Au fait, pour être sûr de ce que tu me dis, pourrais tu me dire ce qui te semble manquer ?
Messages postés
305
Date d'inscription
lundi 7 janvier 2002
Statut
Membre
Dernière intervention
10 août 2011
4
Je viens de télécharger le zip associé à ma source pour vérifier, mais il me semble que rien ne manque. Par contre, ne recharche pas de fichiers spécifiques à Visual Studio, puisque comme je l'ai dit précédemment dans la description de la source, le tout à été fait avec SharpDevelop.
Messages postés
21
Date d'inscription
dimanche 15 février 2004
Statut
Membre
Dernière intervention
11 janvier 2008

le zip n'st pas complet

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.