SAUVEGARDE/CHARGEMENT DE PROPRIÉTÉS D'UN OBJET

/*
 * 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;
		}
	}
}