begin process at 2008 08 08 21:37:32
1 223 607 membres
365 nouveaux aujourd'hui
14 230 membres club

Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum.
Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

GESTIONNAIRE DE FICHIERS INI


Information sur la source

Catégorie :Fichiers / Disque Source .NET ( DotNet ) Classé sous : fichier, ini Niveau : Débutant Date de création : 01/10/2004 Date de mise à jour : 01/10/2004 14:25:20 Vu : 14 345

Note :
8,89 / 10 - par 9 personnes
8,89 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10

Commentaire sur cette source (20)
Ajouter un commentaire et/ou une note

Description

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

  • 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);
  • }
  • }
  • }
  • }
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!
01 octobre 2004 10:59:49 :
Ajout des commentaires
01 octobre 2004 14:19:01 :
Ptite modif d'accesseurs
01 octobre 2004 14:25:20 :
Encore une ptite modif ;-)
  • signaler à un administrateur
    Commentaire de Bidou le 01/10/2004 22:49:14 administrateur CS

    J'ai pas testé ton code, mais disons que le temps n'est plus tellement au fichier .ini mais plutôt à l'xml, non?

    Enfin, c'est ce que je peux te conseiller!

  • signaler à un administrateur
    Commentaire de bucherb le 03/10/2004 07:31:16

    On est tout a fait d'accord sur ce point, mais pas tout le monde maitrise encore cette technologie, alors le fichier ini pour faire de petites variables modifiables très facilement reste encore le plus facile a utiliser.

  • signaler à un administrateur
    Commentaire de gg00xiv le 03/10/2004 13:54:57

    Sincérement, non.
    La tu t'es pris la tête à coder un gestionnaire de fichiers ini, alors que ceux existant pour XML sont bien plus élaborer et déjà intégrés au Framework.NET.

  • signaler à un administrateur
    Commentaire de bucherb le 04/10/2004 09:02:54

    Pour la petite histoire, je me suis pas pris la tête, et puis si qqun préfère utiliser les fichiers ini que le XML, comme ça il peut ;-)

    Ma grand mère par exemple, je pense pas qu'elle sache utiliser le XML mdr, alors qu'un fichier INI c'est tellement simple.

  • signaler à un administrateur
    Commentaire de gg00xiv le 04/10/2004 11:32:51

    lol, j'adore !!!

  • signaler à un administrateur
    Commentaire de Arthenius le 05/10/2004 11:04:56

    j'avais poster un code qui permet (entre autre) de genere un xml qui peut servir de fichier ini....

    avec un objet serializable....

    c bien pratique....et très simple d'utilisation...
    tu creer un objet...une structure par exemple...
    tu la rempli de données...
    tu genere le fichier xml....
    et voilou....


    voir le code sur le bouton OK(pour l'ecriture du fichier) et sur le form load (pour la lecture...)

    le tout ce trouve la :

    http://www.csharpfr.com/code.aspx?id=23015

  • signaler à un administrateur
    Commentaire de bucherb le 05/10/2004 11:07:17

    J'ai déjà vu ta source, et si jamais pour t'en convaincre tu peux lire les autres commentaires ;-)

  • signaler à un administrateur
    Commentaire de Arthenius le 05/10/2004 11:07:39

    cela dis...

    l'idée est bonne...

    pour les grands mere ;o))))

    je plaisante.... :o))))

  • signaler à un administrateur
    Commentaire de yoannd le 09/12/2004 15:10:40

    Moi je trouve que ce code est bien. D'accord, l'utilisation de classe sérialisées est très pratique et très interessant, mais il arrive parfois que l'on veuille récupérer les paramêtres d'une autre application, plus ancienne, et que celle-ci utilise des fichiers ini... ce code n'est donc pas forcément inutile comme le laissait entendre gg00xiv.

  • signaler à un administrateur
    Commentaire de Arthenius le 09/12/2004 16:17:40

    certes...

    :o))

  • signaler à un administrateur
    Commentaire de Light Angel le 02/01/2005 18:25:29

    Franchement, je trouve que ce code était celui qu'il manquait pour ceux qui sont comme moi allergique a l'XML (déja, quand on l'a apprit qu'il fallait commenter les codes C# avec du Xml ...) Bref, pour faire court : 10/10

  • signaler à un administrateur
    Commentaire de pietou le 12/08/2005 15:42:50

    C'est vrai que c'est une classe sympa, mais dans le genre, je préfère http://www.codeproject.com/csharp/ReadWriteXmlIni.asp

    Là, ça fait tout! XML, ini, config, et registry
    Une classe par type et une démo bien faite.

    Donc, un 7/10.

  • signaler à un administrateur
    Commentaire de thebigboss le 10/12/2005 17:24:11

    Moi je vais commencer par regarder ton fichier car les .ini ca semble accessible à tout le monde. Je passerai peut-être ensuite au xml (que je ne connais pas du tout).

    Merci en tous cas pour ton fichier

  • signaler à un administrateur
    Commentaire de sharperton le 02/01/2006 08:33:00

    Bel exemple de la programmation. Les fichiers ".ini" c’est la réalité des environnements d’aujourd’hui (et encore pour certain temps), il est inutile de discuter. Le programme n’utilise pas les fonctions win32 (comme http://www.codeproject.com/csharp/ReadWriteXmlIni.asp) et c’est un plus.
    On pourrait y ajouter les méthodes
    public string[] GetSections()
    public string[] GetSection(string section)
    ...et ça serait parfait ;-)

  • signaler à un administrateur
    Commentaire de themioux le 26/07/2007 11:27:52

    Je remonte ce sujet pour dire que cette classe peut être trèèèès utilse...

    Imaginons un instant que vous faites un programme qui utilise uniquement des fichiers ini... (et il y en a encore beaucoup... pour des raison de taille de transfert... un ini est beaucoup plus petit qu'un xml qui fais la même chose (vous voulez des exemples ? Folding@Home enregistre ses paramètres dans un fichier ini (déguisé en .cfg ^^), Neverwinter Nights (1) enregistre aussi ses paramètres dans des fichiers ini... et si je vous parles de ces 2 programmes, c'est que j'ai développé un configureur pour NWN en VB.Net (accès à certaines options invisibles dans l'interface de NWN), et un petit plugin pour LCDStudio qui permet de lire les infos de F@H)

    Il y a aussi mame qui utilise du ini (et depuis plus récemment aussi du XML)... bref, le ini n'est pas mort

  • signaler à un administrateur
    Commentaire de surfzoid le 03/06/2008 17:06:21 9/10

    C'est exacte , j' ecrit ClamWinRT (sf.net) et je chercher justement cette classe puisque le logiciel ClamWin ne semble pas ecrit en .NET et utilise ce bon vieu fichier INIT, un peut comme sous unix/linux d'ailleurs lol :D rien que pour ?a 9/10, severe punition lol

  • signaler à un administrateur
    Commentaire de surfzoid le 03/06/2008 17:12:36

    private const string newline = "\r\n";
    C'est mieux pour les autres OS :
    private const string newline = Environment.NewLine;
    :D

  • signaler à un administrateur
    Commentaire de themioux le 03/06/2008 18:04:23

    Sauf que ce n'est pas forcément vrai...

    Prenons windows pour exemple : suivant le fichier que tu ouvre, le NewLine c'est \r\n ou \n (sois dit en passant, il est normalement plus logique d'utiliser \r\n pour un retour à la ligne qu'un \n, car sinon, une imprimante pourrait ne pas faire de retour chariot et imprimer sa ligne suivante sous l'autre, mais en restant au même niveau sur la ligne)

    Enfin bref, Environment.NewLine dépends de l'OS, mais un même fichier peut être utilisé sous 2 OS différents (exemple d'au dessus, Neverwinter Nights qui a un client Windows et une client Linux) et tu pourrait utiliser \n sur ton fichier sous Linux (car Environment.NewLine sous Linux doit renvoyer \n non ? je sais pas j'ai jamais testé :P) et pourtant, ton fichier .ini attends un \r\n

    A mon avis, cette ligne est à adapter en fonction de l'utilisation du programme. Windows ? Linux ? Interportable ? Bridé à une machine ? Et sur mac ? (il n'y a que le \r :P)

  • signaler à un administrateur
    Commentaire de surfzoid le 04/06/2008 10:33:26

    C'est vrai globalement tu as raison, mais dans ce contexte , fichier init, soit ont prends un fichier existant, donc cr?e sur l'OS, soit on le cr?e au premier lancement du soft, donc toujours sur l'OS existant.
    Donc pour ?tre coh?rent dans tout les cas de figure il faut absolument utiliser environment.newline, car sinon tu sera en d?saccord avec l'OS sur lequel tourne le logiciel qui utilise cette classe.
    Je suis plus linux + Mono et donc je pensse r?gulierement crossplatform lol :D :
    http://sourceforge.net/projects/cs-obexftp/
    http://sourceforge.net/projects/rpmspecmanager/
    et je suis aussi la : http://mono-project.com/OpenSUSE_Build_Service
    lol :D

  • signaler à un administrateur
    Commentaire de themioux le 04/06/2008 10:45:49

    Bah le truc c'est que perso, j'ai tendance à coder comme un goret... J'ai découvert String.Empty il y a peu alors que ça fais plus d'un an que je code en asp.net :D

    Dans un nouveau projet, je suis d'accord pour le Environment.NewLine (et même en règle générale d'ailleurs) et je pense souvent au cross platform (mon pc est sous windows, je travaille au taff sous windows, et les 2 seules choses qui me forcent à rester sous windows @home c'est le fait que ma carte télé fonctionne mal (hybride, c'est un peu la merde à faire fonctionner, bien que j'ai fais un tuto pour ca sous ubuntu) et le fait que mon ordinateur démarre 2 ou 3 fois nickel sous linux, et la quatrième, j'ai un bel écran noir, alors que je n'ai touché à aucune config... même en mode console), ainsi qu'à l'accessibilité des sites web et la compatibilité cross-browser (généralement je teste IE7 (parce que flême d'installer MultipleIE)/Firefox 2/Opera 9/Lynx et dès fois même konqueror et Evince sur une machine virtuelle. Enfin ça c'est coté perso, parce qu'au taff c'est "IE6 et compatiblité fonctionnelle avec Firefox" et vu les délais, vaut mieux pas trop que je joue la compatiblité à 100% :D

    Tout ça pour dire : Environment.NewLine dès qu'aucune contrainte n'est posée :D

Ajouter un commentaire

Pub



Appels d'offres

CalendriCode

Août 2008
LMMJVSD
    123
45678910
11121314151617
18192021222324
25262728293031

VS Express FR Gratuit !

VS Express en français et 100% gratuit !

Téléchargements

Logiciels à télécharger sur le même thème :

Boutique

Boutique de goodies CodeS-SourceS