begin process at 2010 02 09 22:38:56
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Fichiers / Disque

 > GESTIONNAIRE DE FICHIERS INI

GESTIONNAIRE DE FICHIERS INI


 Information sur la source

Note :
9,09 / 10 - par 11 personnes
9,09 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
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 :18 606

Auteur : bucherb

Ecrire un message privé
Site perso
Commentaire sur cette source (24)
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!


 Historique

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 ;-)

 Sources du même auteur

Source avec Zip Source avec une capture Source .NET (Dotnet) DIRECTX 9 : LES EFFETS DIRECTSOUND (ECHO, DISTORTION, ETC)
Source avec Zip Source avec une capture Source .NET (Dotnet) APPLIQUER UNE IMAGE QUELCONQUE SUR UN CURSEUR
Source .NET (Dotnet) RECHERCHE DANS UNE STRING
Source .NET (Dotnet) TRANSFORMATION ENTIER-BINAIRE
Source avec Zip Source avec une capture Source .NET (Dotnet) CONTROL "LOG" À LA MATRIX

 Sources de la même categorie

Source avec Zip PILOTER WORD VIA MICROSOFT.OFFICE.INTEROP.WORD par whismeril
Source avec Zip PILOTER EXCEL VIA MICROSOFT.OFFICE.INTEROP.EXCEL par whismeril
Source avec Zip Source .NET (Dotnet) CHECK IDENTICAL FILES par eldim
Source avec Zip Source avec une capture Source .NET (Dotnet) RICHTEXTBOX NUMÉROTÉ (NUMÉROS DE LIGNES) par jray
Source avec Zip Source avec une capture SURVEILLER FICHIERS CRÉÉS AVEC FILESYSTEMWATCHER AMÉLIORÉ par TheOnlyMaX

 Sources en rapport avec celle ci

Source avec Zip Source avec une capture Source .NET (Dotnet) RECHERCHE ET GESTION DE FICHIERS PERSONNALISÉES par JeremyLecouvert
Source .NET (Dotnet) GREP POUR WINDOWS par Warny
Source avec Zip Source .NET (Dotnet) CLASSE FICHIER INI COMPLET par filipegomes
Source avec Zip Source .NET (Dotnet) PARSEUR DE FICHIER INI par dragonkeeper
Source avec Zip Source avec une capture Source .NET (Dotnet) LECTURE DES PLAYLITS M3U par nounours21_6

Commentaires et avis

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!

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.

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.

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.

Commentaire de gg00xiv le 04/10/2004 11:32:51

lol, j'adore !!!

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

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 ;-)

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))))

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.

Commentaire de Arthenius le 09/12/2004 16:17:40

certes...

:o))

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

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.

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

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 ;-)

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

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

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

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)

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

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

Commentaire de baldemic le 16/12/2008 16:04:02

Excelente source pour un débutant comme moi.
Note 10/10
Tout fonctionne nickel, mais je ne sais pas comment utiliser les fonctions "DeleteKey" et "SetKey".

J'ai envoyé un message privé, mais si quelqu'un connait...
Merci

Commentaire de peug le 08/10/2009 17:10:08 10/10

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

Commentaire de GooseIsGod le 30/12/2009 17:24:59 10/10

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.

Commentaire de yoannd le 13/01/2010 02:17:07

@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 ^^

 Ajouter un commentaire


Discussions en rapport avec ce code source dans le forum

Ecriture / lecture d'un fichier INI [ par Tsu91 ] Bonjour,Je débute en c# et ma question est simple:Comment écrire et lire dans un fichier Ini ?merci :)Séb Fichier ini [ par joe2005 ] Bonjour &#224; vous tous, J'aurai besoin de votre aide. Il faut que je cr&#233;e un fichier de configuration *.ini pour mon h&#233;bergeur. Mais, je n [C#] INI vs XML, DataSet vs INI [ par scoubidou944 ] Actuellement, mon programme utilise un fichier Ini pour sa configuration.Voulant migrer ce fichier vers un format XML, plusieurs choix sont possibles. acceder a un fichier .ini [ par jesaipa_1 ] Slt a tous, je voudrais savoir comment on acc&#232;de &#224; un fichier .ini pour recuperer des infos.Merci besoin d'aide asp.net webservice [ par mourad183 ] bonjour tout le monde,je debute a peine au dotNet, au fait j'ai plusieurs questions a vous poser esperant trouver mon bonheur,je suis en fin de cycle Parametre regionaux [ par chouchoune80 ] Bonjour,Je pense que ma question sera valable pour toutes les futures applications que je vais développer. Je souhaiterai savoir comment  créer un fic Problème de mémoire [ par nicompx ] Bonjour, J'ai un problème de mémoire avec une application.En gros : le programme insère EN BOUCLE dans une base de données Oracle des lignes.Je rega fichiers de configuration [ par gabs77 ] Bonjour,Je voudrais savoir ce que vous me connseiller comme fichier de configuration à générer pour un programme. Je pense au fichier .ini mais je ne ini files avec C# [ par ellen ] Comment fait-on pour lire un fichier ini (ou de configuration) avec C#?Je souhaite avoir accès à des paramètres dans un fichier de configuration avec [Aide] Léger problème avec GetPrivateProfileString () [ par Nixeus ] Bonjour à tous !Développeur c++, je me suis mis à c# depuis quelques jours, pour le fun, et j'ai un chti problème avec la lecture d'un fichier ini !!N


Nos sponsors


Sondage...

Comparez les prix

CalendriCode

Février 2010
LMMJVSD
1234567
891011121314
15161718192021
22232425262728

Consulter la suite du CalendriCode

 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,640 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales