Gestionnaire de fichiers ini

Soyez le premier à donner votre avis sur cette source.

Snippet vu 32 921 fois - Téléchargée 36 fois

Contenu du snippet

Cette petite classe à utiliser dans n'importe quel projet vous permet d'accéder aux valeurs contenues dans un fichier INI du genre:

[Section]
clef=valeur

Tout est encapsulé, donc pas de prises de têtes.

Source / Exemple :


using System;
using System.IO;
using System.Text;
using System.Collections;

	/// <summary>
	/// Cette classe permet d'utiliser un fichier ini.
	/// Tout les paramètres qui n'existent pas lors de l'acces sont automatiquement créés.
	/// </summary>
	public class IniFile
	{
		private Hashtable Sections = new Hashtable();
		private string sFileName;

		private const string newline = "\r\n";

		public IniFile (){}

		/// <summary>
		/// Crée une nouvelle instance de IniFile et charge le fichier ini
		/// </summary>
		/// <param name="fileName">Chemin du fichier ini</param>
		public IniFile (string fileName)
		{
			sFileName = fileName;

			if (File.Exists(fileName))
				Load(fileName);
		}

		/// <summary>
		/// Ajoute une section [section] au fichier ini
		/// </summary>
		/// <param name="section">Nom de la section à créer</param>
		public void AddSection (string section)
		{
			if (!Sections.ContainsKey(section))
				Sections.Add(section,new Section());
		}

		/// <summary>
		/// Ajoute une section [section] au fichier ini ainsi qu'une clef et une valeur
		/// </summary>
		/// <param name="section">Nom de la section</param>
		/// <param name="key">Nom de la clef</param>
		/// <param name="value">Valeur de la clef</param>
		public void AddSection (string section, string key, string value)
		{
			AddSection (section);
			((Section)Sections[section]).SetKey(key,value);
		}

		/// <summary>
		/// Retire une section du fichier
		/// </summary>
		/// <param name="section">Nom de la section à enlever</param>
		public void RemoveSection (string section)
		{
			if (Sections.ContainsKey(section))
				Sections.Remove(section);
		}

		/// <summary>
		/// Modifie ou crée une valeur d'une clef dans une section
		/// </summary>
		/// <param name="section">Nom de la section</param>
		/// <param name="key">Nom de la clef</param>
		/// <param name="value">Valeur de la clef</param>
		public void SetValue (string section, string key, string value)
		{
			this[section].SetKey(key,value);
		}

		/// <summary>
		/// Retourne la valeur d'une clef dans une section
		/// </summary>
		/// <param name="section">Nom de la section</param>
		/// <param name="key">Nom de la clef</param>
		/// <param name="defaut">Valeur par défaut si la clef/section n'existe pas</param>
		/// <returns>Valeur de la clef, ou la valeur entrée par défaut</returns>
		public string GetValue (string section, string key, object defaut)
		{
			string val = this[section][key];
			if (val == "")
			{
				this[section][key] = defaut.ToString();
				return defaut.ToString();
			}
			else
				return val;
		}

		/// <summary>
		/// Retourne la valeur d'une clef dans une section
		/// </summary>
		/// <param name="section">Nom de la section</param>
		/// <param name="key">Nom de la clef</param>
		/// <returns>Valeur de la clef, ou "" si elle n'existe pas</returns>
		public string GetValue (string section, string key)
		{
			return GetValue (section,key,"");
		}

		// Indexeur des sections
		private Section this [string section] 
		{
			get
			{
				if (!Sections.ContainsKey(section))
					AddSection(section);

				return (Section) Sections[section];
			}
			set
			{
				if (!Sections.ContainsKey(section))
					AddSection(section);
				Sections[section] = value;
			}
		}

		/// <summary>
		/// Sauvegarde le fichier INI en cours
		/// </summary>
		public void Save ()
		{
			if (sFileName != "")
				Save (sFileName);
		}

		/// <summary>
		/// Sauvegarde le fichier INI sous un nom spécifique
		/// </summary>
		/// <param name="fileName">Nom de fichier</param>
		public void Save (string fileName)
		{
			StreamWriter str = new StreamWriter(fileName,false);

			foreach (object okey in Sections.Keys)
			{
				str.Write("["+okey.ToString()+"]"+newline);

				Section sct = (Section)Sections[okey.ToString()];

				foreach (string key in (sct.Keys))
				{
					str.Write(key+"="+sct[key]+newline);
				}
			}

			str.Flush();
			str.Close();
		}

		/// <summary>
		/// Charge un fichier INI
		/// </summary>
		/// <param name="fileName">Nom du fichier à charger</param>
		public void Load (string fileName)
		{
			Sections = new Hashtable();

			StreamReader str = new StreamReader(File.Open(fileName,FileMode.OpenOrCreate));

			string fichier = str.ReadToEnd();

			string[] lignes = fichier.Split('\r','\n');

			string currentSection = "";

			for (int i=0 ; i<lignes.Length ; i++)
			{
				string ligne = lignes[i];
				

				if (ligne.StartsWith("[") && ligne.EndsWith("]"))
				{
					currentSection = ligne.Substring(1,ligne.Length-2);
					AddSection(currentSection);
				}
				else if (ligne != "")
				{
					char[] ca = new char [1] {'='};
					string[] scts = ligne.Split(ca,2);
					this[currentSection].SetKey(scts[0],scts[1]);
				}
			}
			this.sFileName = fileName;

			str.Close();
		}

		// Structure de donnée des sections
		private class Section
		{

			private Hashtable clefs = new Hashtable();

			public Section (){}

			/// <summary>
			/// Affecte une valeur à une clef et la crée si elle n'existe pas
			/// </summary>
			/// <param name="key">Nom de la clef</param>
			/// <param name="value">Valeur de la clef</param>
			public void SetKey (string key, string value)
			{
				if (key.IndexOf("=") > 0) 
					throw new Exception("Caractère '=' interdit");

				if (clefs.ContainsKey(key))
					clefs[key] = value;
				else
					clefs.Add(key,value);
			}

			/// <summary>
			/// Supprime une clefs
			/// </summary>
			/// <param name="key">Nom de la clef à supprimer</param>
			public void DeleteKey (string key)
			{
				if (clefs.ContainsKey(key))
					clefs.Remove(key);
			}

			/// <summary>
			/// Les clefs contenues dans la section
			/// </summary>
			public ICollection Keys 
			{
				get
				{
					return clefs.Keys;
				}
			}

			/// <summary>
			/// Indexeur des clefs
			/// </summary>
			public string this [string key]
			{
				get
				{
					if (clefs.ContainsKey(key))
						return clefs[key].ToString();
					else
					{
						SetKey (key,"");
						return "";
					}
						
				}
				set
				{
					SetKey(key,value);
				}
			}
		}
	}

Conclusion :


Je ne pense pas que le code soit parfait, si vous avez des améliorations, n'hésitez pas à laisser un commentaire, et je mettrai le code à jour.

Bonne prog!

A voir également

Ajouter un commentaire

Commentaires

Messages postés
1
Date d'inscription
dimanche 6 décembre 2009
Statut
Membre
Dernière intervention
8 mars 2013

Code très utile, je m'en suis déjà servis plusieurs fois et je t'en remercie.
C'est vraiment pratique pour le stockage de masse surtout, car stocker plusieurs miliers de valeurs dans un pauvre xml... alors qu'ici dans un .ini on à l'avantage de la taille mais aussi de la rapidité de création (c'est déjà plus simple de faire un .ini que de respecter toute la structure hyper restrictive du XML).

10/10 :D
Messages postés
11
Date d'inscription
jeudi 1 septembre 2005
Statut
Membre
Dernière intervention
1 avril 2011

sympa et bien conçu. les fichiers ini ont un avantage, c'est de pouvoir les modifier/editer avec notepad tres simplement et facilement (rien de plus simple que de rajouter une clé dans un ini). ce qui est moins le cas avec des fichiers xml. malgré qu'on puisse faire autrement avec xml, je considère que ce code a toput de mem un interet, si on préfère pour X raisons perso les fichiers ini pour stocker ses paramètres. il y aussi des situations ou le fichier ini est incontournable: par ex avec des vieux (mais neanmoins encore existants) scripts .bat qui utilisent ces fichiers
Messages postés
305
Date d'inscription
lundi 7 janvier 2002
Statut
Membre
Dernière intervention
10 août 2011
4
@GooseIsGod : Merci ! Merci ! MERCI !!! Enfin quelqu'un de censé !!! rhaaaa... j'vous jure, des morceaux de code issus d'une branlette cérébrale, j'en vois tous les jours dans mon taf, et j'en ai plus que marre ! Ne sacrifions pas les performances pour une meilleur lisibilité, mais l'inverse est tout aussi vrai :) je vous laisse méditer là-dessus ^^
Messages postés
2
Date d'inscription
jeudi 11 septembre 2003
Statut
Membre
Dernière intervention
16 avril 2008

Un petit UP juste pour donner une note et dire que la structure XML c'est bien si l'on en a besoin ... après 26 ans de développement informatique, s'il y a bien une chose que j'ai retenu c'est que les fonctions le plus simples sont souvent les meilleurs.
Messages postés
234
Date d'inscription
mercredi 25 octobre 2000
Statut
Membre
Dernière intervention
5 octobre 2012

Nickel, je cherchais à code cela pour lire une configuration d'un ini existant... !
Afficher les 26 commentaires

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.