Feedback

C# - ini Datei anlegen - mit Dictionary

Veröffentlicht von am 23.11.2010
(20 Bewertungen)
Klassen: cInifile und cDic
--------------------------

Die beiden Klassen stellen insg. 10 Funktionen zum anlegen/bearbeiten von ini-Dateien zur Verfügung.

Dazu wird u.a. eine eigen kleine Dictionary-Klasse verwendet. Dieses Dic. kann angelegt und bearbeitet werden, und anschliessend in ein ini-Dateiformat gespeichert werden. Daie ini-Datei kann natuerlich auch in das Dic. eingelesen werden ect.

Eine Dokumentation findet ihr ganz oben im source.

viel Spass
GFU-Schulungen  [Anzeige]

VB.NET Komplett

Sie stehen vo der Aufgabe, individuelle Anwendungen für Windows zu schreiben. Hier ist VB.NET die optimale Sprache. Sie erlernt sich recht leicht und passt sich komplett in die .NET Umgebung von Microsoft ein. Nach der Schulung entwickeln Sie anwenderfreundliche Programme in VB.NET . Mit den objektorientierten Modellen in VB.NET erzeugen Sie außerdem wiederverwendbare Komponenten.

C# 2017/2015/2013 Grundlagen

Nach Abschluss des Kurses sind Ihnen die Datentypen und Klassenbibliotheken von C# bekannt. Außerdem sind Sie in der Lage, mit Variablen umzugehen und deren Typen zu konvertieren. Sie definieren Namespaces und setzen diese ein, Sie erstellen eigene Klassen  und bauen Trouble Shooting ein.

// WICHTIG - zusätzlich diese Namespaces einbinden  - wenn noch noetig
// using System.Collections;
// using System.Collections.Generic;
// using System.IO;
// using System.Xml;
// using System.Xml.Linq;
// using System.Linq;
// using System.Text;
// using System.Runtime.InteropServices; 
// -------------------------------------------------



#region cIniFile - ini-datei lesen,schreiben...
    /// <summary> Domumentation der Klasse -            by A.Roters - Freeware - 2010
    /// 
    /// Diese Klasse kann eine sog. ini-Datei anlegen bzw. bearbeiten ( in ascii und xml-Format )
    ///
    /// Zwei Möglichkeiten stehen zur Verfügung: 
    /// 1. direktes schreiben in iniDatei  und/oder
    /// 2. über eine eigens geschriebene kleine Dictionary-Class !!!!!
    /// 
    /// 
    /// // ------------------------------------------------------------------------------------------------------
    /// Erklärung zum Dictionary   DIC-NAME:  myInifileInstanz.my_DIC.INI_Dictionary
    /// ------------------------
    /// Der sog. MASTERKey setzt sich im Dictionary aus  SECTIONNAME+subKEY zusammen.
    /// Value => (ist der Wert hinter dem  =-Zeichen des subKeys)
    /// Die Klasse splittet diese dann wieder auseinander       ( Key   ,  value  )
    /// Def.: Dictionary<string[2],string>( (s[0]="Section",s[1]="Key") , "value" )
    ///                                   (           MASTERKey         ,  value  )
    /// // -------------------------------------------------------------------------------------------------------
    /// 
    /// Dateiname: myDateiName.ini oder myDateiName.xml
    /// 
    /// Format Beispiel:
    /// ----------------
    /// ini-Datei (schreiben und lesen)
    /// ------------
    /// [mySektion1]         -> SECTION s[0]
    /// my_key1=value1       -> my_key1 s[1]  -> s[0]+s[1] diese beiden Werte sind im Dictionary der sog. MasterKEY     
    /// my_keyN=value2                           (hinter dem =-Zeichen steht dann value)                               
    /// [mySection2]
    /// my_key=value      
    /// 
    /// 
    /// und als xml-Datei (nur schreiben)
    /// -----------------
    /// <?xml version="1.0" encoding="utf-8" ?> 
    /// - <TESTINI_DATEN_ROOT_NAME>
    ///  - <mySektion1>
    ///    <my_key1>value1</my_key1> 
    ///    <my_keyN>value2</my_keN1> 
    ///  </mySektion1>
    ///  - <mySection2>
    ///    <my_key>value</my_key> 
    ///  </mySection2>
    /// </TESTINI_DATEN_ROOT_NAME>
    /// 
    /// 
    /// 
    /// WICHTIG - zusätzlich diese usings einbinden  - wenn noetig
    /// ----------------------------------------------------------
    /// using System.Collections;
    /// using System.Collections.Generic;
    /// using System.IO;
    /// using System.Xml;
    /// using System.Xml.Linq;
    /// using System.Linq;
    /// using System.Text;
    /// using System.Runtime.InteropServices;
    /// 
    /// -------------------------------------------------------------------------------------------------------------
    ///
    /// Alle Funktionen:
    /// ----------------
    /// - . instanzieren - IMMMER !!!!! 
    /// - cInifile myInifile = new cIniFile("c:\meineIniDatei", OPEN_INI_MOD_.NEW);       // neuanlage iniDatei
    /// - cInifile myInifile = new cIniFile("c:\meineIniDatei", OPEN_INI_MOD_.READWRITE); // neuanlage oder bearbeiten
    /// 
    /// - . iniDatei direkt beschreiben und Values lesen - diese zwei Funktionen schreiben/lesen direkt aus/in die iniDatei !!!!! 
    /// - myInifile.IniWriteValue("SECTION1" , "KEY1_1" , "value1a");     // den Eintrag direkt in iniDatei schreiben
    /// - string myValue = myInifile.IniReadValue("SECTION1" , "KEY1_1"); // Value direkt aus iniDatei lesen/holen 
    /// 
    /// - . Dictionary  - myInifile.myDIC. - einlesen aus iniDatei in Dic. und schreiben von Dic. in iniDatei  
    /// - myInifile.IniReadAll_fromFile_intoDictionary("" , cIniFile.INI_READ_MOD_.ALL_SECTIONS); // eine iniDatei in Dic. einlesen
    /// - myInifile.IniWriteAll_FromDictionary_IntoFile();   // das Dictionary in iniDatei schreiben; die iniDatei wird dabei neu erstellt
    /// 
    /// - . Dictionary - vier Funktionen zum Arbeiten - myInifile.myDIC.
    /// - myInifile.my_DIC.myAdd("SECTION_1" , "Key1" , "value"); // den Eintrag ins Dictionary schreiben; wenn nicht bereits vorhanden
    /// - myInifile.my_DIC.myRemove("SECTION_1" , "Key2");        // den Eintrag aus Dictionary loeschen; wenn vorhanden
    /// - string myValue=myInifile.my_DIC.myGetValue("SECTION_2" , "Key1"); // Value des Eintrags holen; wenn vorhanden
    /// - myInifile.my_DIC.mySetValue("SECTION_2" , "Key1","newValue");     // Value des Eintrags neu setzen; wenn Eintrag vorhanden  
    ///
    /// - 5. Zusatzfunktion - schreiben iniDatei in xmlDatei
    /// - myInifile.IniWriteAll__IntoXmlFile( @"TESTINI_DATEN_ROOT"); // schreiben in xmlDatei 
    /// - string[] liste=myInifile.IniReadAll(); // alles iniDatei_Zeilen lesen und als String-Array speichern
    /// 
    /// - 6. WICHTIG - zusätzlich diese Namespaces einbinden  - wenn noch noetig
    /// using System.Collections;
    /// using System.Collections.Generic;
    /// using System.IO;
    /// using System.Xml;
    /// using System.Xml.Linq;
    /// using System.Linq;
    /// using System.Text;
    /// using System.Runtime.InteropServices;
    /// 
    /// 
    /// - 7. zusätzlich diese VERWEISE einbinden - wenn noetig
    /// System.Xml;
    /// System.Xml.Linq;
    /// 
    /// // --------------------------------------------------------------------------------------------------------
    /// 
    /// Beispiele:
    /// ----------
    /// 
    /// //1. Möglichkeit - nur zwei eingeschränkte Funktionalität - Daten werden direkt in ini-Datei geschrieben oder ein value kann ausgelesen werden
    /// ---------------------
    /// // Instanz - IMMER ( natuerlich nur einmal pro iniDatei ) !!!!!
    /// cInifile myInifile = new cIniFile("c:\meineIniDatei", OPEN_INI_MOD_.NEW);         // neue iniDatei anlegen; eine schon vorhandene iniDatei wird vorher geloescht
    /// //oder alternativ 
    /// //cInifile myInifile = new cIniFile("c:\meineIniDatei", OPEN_INI_MOD_.READWRITE); // neue oder vorhandene iniDatei bearneiten; die vorhandene iniDatei wird weiter bearbeitet oder eine neue angelegt !!!
    /// 
    /// myInifile.IniWriteValue("SECTION1" , "KEY1_1" , "value1a"); // neuen Eintrag direkt in die iniDatei schreiben; wenn nicht schon vorhanden
    /// myInifile.IniWriteValue("SECTION1" , "KEY1_2" , "value1b"); // dito
    /// myInifile.IniWriteValue("SECTION2" , "KEY2_1" , "value1a"); // dito  usw...
    /// string myValueFromSectionKey=myInifile.IniReadValue("SECTION1" , "KEY1_2");  // Beispiel fuer einlesen eines Value direkt aus inidatei 
    /// 
    /// // Sonderfunktion - nur wenn eine iniDatei schon vorher angelegt wurden;  sprich vorhanden ist dann
    /// myInifile.IniReadAll_fromFile_intoDictionary("" , cIniFile.INI_READ_MOD_.ALL_SECTIONS); // aus einer iniDatei alles einlesen und in Dictionary schreiben !!!!!
    /// // oder alternativ  nur eine bestimmte Section komplett einlesen mit
    /// //myInifile.IniReadAll_fromFile_intoDictionary("SECTION1" , cIniFile.INI_READ_MOD_.ONLY_ONE_SECTION);
    /// 
    /// 
    /// // -------------------------------------------------------------------------------------------
    /// // ... jetzt kann z.B. mit 2.Möglichkeit das Dictionary bearbeitet werden und dieses dann zum 
    /// // Schluss wieder in einem Rutsch in die ini-Datei geschrieben werden !!!!! 
    /// // -------------------------------------------------------------------------------------------
    /// 
    /// 
    /// //2.Möglichkeit - viel umfangreicher -  mit Hilfe von Dictionary !!!
    /// //----------------------
    /// // Instanz - IMMER ( natuerlich nur einmal pro iniDatei ) !!!!!
    /// cInifile myInifile = new cIniFile("c:\meineIniDatei", OPEN_INI_MOD_.NEW);         // neue iniDatei anlegen; die vorhandene iniDatei wird vorher geloescht
    /// //oder alternativ
    /// //cInifile myInifile = new cIniFile("c:\meineIniDatei", OPEN_INI_MOD_.READWRITE); // neue oder vorhandene iniDatei bearneiten; die vorhandene iniDatei kann weiter bearbeitet werden oder eine neue iniDatei wird angelegt !!!
    ///
    /// // Sonderfunktion - nur wenn eine iniDatei schon vorher angelegt wurden;  sprich vorhanden ist dann
    /// myInifile.IniReadAll_fromFile_intoDictionary("" , cIniFile.INI_READ_MOD_.ALL_SECTIONS); // aus einer vorhandenen iniDatei alles lesen und in Dictionary schreiben !!!!!
    ///
    /// // jetzt weiter arbeiten... 
    /// myInifile.my_DIC.myAdd("SECTION_1" , "Key1" , "value"); // neuen Eintrag direkt ins Dictionatry schreiben ; Achtung es wird nicht direkt in die ini-Datei geschrieben !!!!!
    /// myInifile.my_DIC.myAdd("SECTION_1" , "Key2" , "value"); // dito
    /// myInifile.my_DIC.myAdd("SECTION_2" , "Key1" , "value"); // dito
    /// myInifile.my_DIC.myAdd("SECTION_2" , "Key2" , "value"); // dito 
    /// 
    /// myInifile.my_DIC.myRemove("SECTION_1" , "Key2");                  // Beispiel fuer loeschen  Section/Key  in Dic. 
    /// myInifile.my_DIC.mySetValue("SECTION_2" , "Key1","neyValue");     // Beispiel fuer aender Value eines Section/Keys in Dic.
    /// string myValue=myInifile.my_DIC.myGetValue("SECTION_2" , "Key1"); // Beispiel fuer lesen Value eines Section/Keys in Dic.
    /// 
    /// // WICHTIG - zum Schluss - jetzt erst das Dic. in ini-Datei schreiben !!!!!  WICHTIG !!!!!!
    /// myInifile.IniWriteAll_FromDictionary_IntoFile();                  // jetzt das komplette Dic. in ini-Datei schreiben
    ///
    /// // --------------------------------------------------------------------------------------------------------
    /// 
    /// Zusammenfassung:
    /// ----------------
    /// Man kann natürlich Möglichkeit1 und Möglichkeit2 miteinander wunderbar kombinieren.
    /// -  mit Möglichkeit1  -die Datei schnell aufbauen und dann mit
    /// -  Möglichkeit2      -diese bearbeiten/auslesen und wieder wegschreiben.
    /// 
    /// // ---------------------------------------------------------------------------------------------------------
    /// 
    /// Natürlich ist es auch nur mit dieser 2.Möglichkeit ohne weiteres machbar eine 
    /// iniDatei anzulegen/bearbeiten (ohne Möglichkeit 1)
    /// -----------------------------------------------------------------------------
    /// Beispiel:
    /// ---------
    /// // Instanz - IMMER ( natuerlich nur einmal pro iniDatei) !!!!!
    /// cInifile myInifile = new cIniFile("c:\meineIniDatei", OPEN_INI_MOD_.READWRITE); // oder OPEN_INI_MOD_.NEW ;  oeffnen oder anlegen iniDatei
    /// // nur wenn iniDatei vorhanden ist, diese dann mit der folgenden Funktion komplett einlesen ....
    /// // myInifile.IniReadAll_fromFile_intoDictionary("" , cIniFile.INI_READ_MOD_.ALL_SECTIONS); // iniDatei in Dic. laden
    ///
    /// // .....und nun mit myADD/myGETValue/mySETValue/myRemove  aus  cDic-Klasse  die iniDatei bzw. Dic. bearbeiten 
    /// myInifile.my_DIC.myAdd("SECTION_1" , "Key1" , "value");
    /// myInifile.my_DIC.myAdd("SECTION_1" , "Key2" , "value");
    /// myInifile.my_DIC.myAdd("SECTION_2" , "Key1" , "value");
    /// 
    /// // usw.... siehe funktionsbeschreibung weiter oben 
    /// 
    /// // WICHTIG !!!! - und dann zum Schluss alles in die iniDatei zurückschreiben !!!!!! WICHTIG !!!!!
    /// myInifile.IniWriteAll_FromDictionary_IntoFile();  
    /// 
    ///  
    /// // ---------------------------------------------------------------------------------------------------------
    /// 
    /// So jetzt noch zwei Zusatz-Funktion:
    /// -----------------------------------
    /// - myInifile.IniWriteAll__IntoXmlFile( @"TESTINI_DATEN_ROOT_NAME"); // die iniDatei wird zusätzlich in eine xml-Datei geschrieben; nur in Verbindung mit gefuelltem Dictionary möglich !!!!!  
    /// - string[] liste=myInifile.IniReadAll(); // alles iniDatei_Zeilen lesen und als String-Array zu verfügung stellen
    /// 
    /// // ---------------------------------------------------------------------------------------------------------
    /// 
    /// 
    /// //und noch ein Show-Beispiel:  Dictionary komplett einlesen und anzeigen  ect.....
    ///       foreach( KeyValuePair<string[] , string>  d  in  myInifile.my_DIC.INI_Dictionary )
    ///        {
    ///            //                             MASTERKey                   -             Value
    ///            //              Sectionname       -          subKey        -             Value
    ///            MessageBox.Show( d.Key[0] +" -> "+"Key= ["+ d.Key[1] +"]   value= ["+ d.Value +"]");
    ///        }
    /// 
    /// 
    /// 
    /// nun viel Spass
    /// A.Roters
    /// 
    /// ohne Gewähr
    /// </summary>

    public class cIniFile
    {

        #region Eigenschaften

        // Filenamen fuer ini und xml-Datei
        private string _iniFileName;
        private string _xmlFileName;
        
        private string INI_FILE
        {
            get { return _iniFileName; }
            set { _iniFileName=value; }
        }

        private string XML_FILE
        {
            get { return _xmlFileName; }
            set { _xmlFileName=value; }
        }

        // eigenes Dictionary - siehe cDic-Klasse !!!
        private cDic _my_DIC=new cDic();
        public cDic my_DIC
        {
            get
            {
                return _my_DIC;
            }
            set
            {
                _my_DIC=value;
            }
        }

        // c - Write und Read-Funktion
        [DllImport("kernel32")]
        private static extern long WritePrivateProfileString( string section , string key , string val , string filePath );

        [DllImport("kernel32")]
        private static extern int GetPrivateProfileString( string section , string key , string def , StringBuilder retVal , int size , string filePath );
        
        #endregion
 
        // main
        #region Constructor -  Filename für ini- und xml-Datei festlegen
        /// <summary>
        /// Filename für ini- und xml-Datei festlegen
        /// </summary>
        /// 
        /// enum OPEN_INI_MOD_ -> NEW   neue ini-Datei anlegen; eine vorhandene Datei wird überschrieben !!!
        ///                    -> READ  eine vorhandene ini-Datei kann bearbeitet werden (über cDic - Dictionary)
        ///                    
        /// Aufrufbeispiel:
        /// cInifile myInifile = new cIniFile("c:\meineIniDatei", OPEN_INI_MOD_.NEW)  -> neue iniDatei; die vorhandene iniDatei wird vorher geloescht
        /// cInifile myInifile = new cIniFile("c:\meineIniDatei", OPEN_INI_MOD_.READ) -> eine breits vorher angelegte iniDatei bearbeiten !!! (per my_Dic. )
        /// 
        public enum OPEN_INI_MOD_ { NEW , READWRITE };
        public cIniFile( string filename ,OPEN_INI_MOD_ _MOD)
        {
            // hier werden die Filenamen festgelegt
            INI_FILE = filename+".ini";
            XML_FILE = filename+".xml";

            // wenn iniDatei vorhanden
            if(File.Exists(INI_FILE)==true)
            {
                if(_MOD==OPEN_INI_MOD_.NEW)
                {
                    DialogResult dr=MessageBox.Show("Die Datei "+INI_FILE+ " ist bereits vorhanden !!!\n\nDiese wird überschrieben !!!\n\n\nEs wird aber eine Sicherungsdatei: "+INI_FILE+".orginal angelegt.\n\nDie ini-Datei neu schreiben ?" , "Warnung" , MessageBoxButtons.OKCancel);
                    if(dr==DialogResult.Cancel)
                    {
                        // wenn cancel...Abbruch
                        INI_FILE="";
                        MessageBox.Show("Abbruch");
                    }
                    else
                    {
                        // sonst, Sicherungs-ini-Datei anlegen FILENAME: Filename.original
                        if(File.Exists((INI_FILE+".orginal"))==true)
                            File.Delete(INI_FILE+".orginal");

                        File.Copy(INI_FILE , INI_FILE+".orginal");
                        File.Delete(INI_FILE);
                    }
                }
            }
        }
        #endregion


        #region ini-Datei komplett loeschen
        /// <summary>
        /// </summary>
        /// <returns>bool</returns>
        public bool IniFileDelete()
        {
            bool ret=false;

            if(File.Exists(INI_FILE)==true)
            {
                DialogResult dr=MessageBox.Show("Die Datei "+INI_FILE+ " wirklich loeschen ?" , "Warnung" , MessageBoxButtons.OKCancel);
                if(dr==DialogResult.Cancel)
                {
                    INI_FILE="";
                    MessageBox.Show("Abbruch");
                }
                else
                {
                    File.Delete(INI_FILE);
                    if(File.Exists(INI_FILE)==true)
                    {
                        //MessageBox.Show("error in DeleteIniFile: \n\nDie Datei "+INI_FILE+" konnte nicht geloescht werden");
                        throw new Exception("error in IniWriteValue: \n\nDie Datei konnte nicht geloescht werden");
                    }else
                        ret=true;
                }
            }
            return ret;
        }
        #endregion

        #region ini-datei: Eintrag in iniDatei schreiben
        /// <summary>
        /// Übergabe: Section , Key , Value
        /// 
        /// Formatbeispiel:
        /// ---------------
        /// [TEST_SECTION]
        /// my_key1=my_value     usw....
        /// </summary>
        /// <param name="Section"></param>
        /// <param name="Key"></param>
        /// <param name="Value"></param>
        /// <returns>bool</returns>
        public bool IniWriteValue( string Section , string Key , string Value )
        {
            bool ret=false;

            try
            {
                if(Section.Contains('[')!=true && Section.Contains(']')!=true)
                {
                    if(Key.Contains('[')==true)
                    {
                        //MessageBox.Show("error in IniWriteValue: \n\nUngültiges Zeichen im Keyname \"[\" ");
                        throw new Exception("error in IniWriteValue: \n\nUngültiges Zeichen im Keyname \"[\" ");
                    }
                    if(Value.Contains('[')==true)
                    {
                        //MessageBox.Show("error in IniWriteValue: \n\nUngültiges Zeichen im Valuename \"[\" ");
                        throw new Exception("error in IniWriteValue: \n\nUngültiges Zeichen im Valuename \"[\" ");
                    }

                    // jetzt Satz in iniDatei schreiben
                    if(WritePrivateProfileString(Section , Key , Value , INI_FILE)>0)
                        ret=true;
                }
                else
                {
                    //MessageBox.Show("error in IniWriteValue: \n\nUngültiges Zeichen im Sectionname \"[\" \"]\" ");
                    throw new Exception("error in IniWriteValue: \n\nUngültiges Zeichen im Sectionname \"[\" \"]\" ");
                }
            }
            catch(Exception ex)
            {
                throw new Exception("error in IniWriteValue: \n\n"+ex.Message);
            }

            return ret;
        }
        #endregion

        #region ini-Datei: value von  Section/Key direkt aus iniDatei holen
        /// <summary>
        /// 
        /// </summary>
        /// <param name="Section"></param>
        /// <param name="Key"></param>
        /// <returns>string</returns>
        public string IniReadValue( string Section , string Key )
        {
            StringBuilder temp = new StringBuilder(255);
             //           
            try
            {
                int i = GetPrivateProfileString(Section , Key , "" , temp , 255 , INI_FILE);
            }
            catch(Exception ex)
            {
                throw new Exception("error in IniReadValue: \n\n"+ex.Message);
            }

          return temp.ToString();
        }
        #endregion

        #region ini-Datei komplett in string[] einlesen
        /// <summary>
        /// reine Info-Funktion
        /// </summary>
        /// <returns>string[]</returns>
        public string[] IniReadAll()
        {
            string[] retListe=null;
           
            try
            {
                retListe=File.ReadAllLines(INI_FILE);
            }
            catch (Exception ex)
            {
                throw new Exception("error in IniReadAll: \n\n"+ex.Message);
            }

           return retListe;
        }
        #endregion

        #region ini-Datei in Dictionary einlesen
        /// <summary>
        /// enum INI_READ_MOD_  ->  ONLY_ONE_SECTION  nur eine SECTION der ini-Datei einlesen 
        ///                     ->  ALL_SECTIONS      komplette Datei in Dictionary einlesen
        /// </summary>
        public enum INI_READ_MOD_ { ONLY_ONE_SECTION, ALL_SECTIONS };
        /// <summary>
        /// 
        /// </summary>
        /// <param name="Section"></param>
        /// <param name="_MOD"></param>
        /// <returns>bool</returns>
        public bool IniReadAll_fromFile_intoDictionary( string Section , INI_READ_MOD_ _MOD )
        {
            bool ret=true;
            bool section_found=false;
            bool key_found=false;

            string[] split=new string[2];
            string _sektion="";

            my_DIC.INI_Dictionary.Clear();
           
            try
            {
                // ini-Datei komplett einlesen
                string[] liste=File.ReadAllLines(INI_FILE);
                
                if(liste.Length<=0)
                {
                    throw new Exception("\nFile: "+INI_FILE+" not found or empty");
                }

                foreach(string s in liste)
                {
                    
                        if(section_found==true && s[0]=='[' && _MOD==INI_READ_MOD_.ONLY_ONE_SECTION)
                            break;

                        // hier den Sectionname selber holen , aber nur wenn alle Sections eingelesen werden sollen !!
                        if(s[0]=='[' && string.IsNullOrEmpty(s)==false && _MOD==INI_READ_MOD_.ALL_SECTIONS)
                        {
                             _sektion=s.Substring(1 , s.Length-2);
                        }

                        // hier die Values zu der Section
                        if(section_found==true && s[0]!='[' && string.IsNullOrEmpty(s)==false)
                        {
                            split.Initialize();
                            split=s.Split('=');
                            key_found=true;

                            AddIntoDictionary(_sektion , (split.GetValue(0)).ToString() , (split.GetValue(1)).ToString());

                        }

                        if(_MOD==INI_READ_MOD_.ONLY_ONE_SECTION)
                        {
                            if(s.Contains(Section)==true && key_found==false)
                            {
                                section_found=true; // nur die angegebene Section einlesen !!!
                            }
                        }else
                            section_found=true; // alle Sections einlesen !!!
                }
          
            }
            catch(Exception ex)
            {
                ret=false;
                my_DIC.INI_Dictionary.Clear();
                throw new Exception("error in IniReadAll_IntoDictionary: \n\n"+ex.Message);
            }

            return ret;
        }
        #endregion

        #region ini Section+Key = newKey  +   value - ADD eintrag in Dic. - private
        private void AddIntoDictionary( string Section , string Key , string Value )
        {
            string[] _newKey=new string[2];
            _newKey[0]=Section;
            _newKey[1]=Key;

            my_DIC.INI_Dictionary.Add(_newKey , Value);

        }
        #endregion

        #region iniDatei loeschen - privat.
        private bool DelIniFile()
        {
            bool ret=true;
            File.Delete(INI_FILE);
            if(File.Exists(INI_FILE)==true)
            {
                ret=false;
                //MessageBox.Show("error in DelIniFile: \n\nDie Datei "+INI_FILE+" konnte nicht geloescht werden");
                throw new Exception("error in DelIniFile: \n\nDie Datei konnte nicht geloescht werden");

            }
            return ret;
        }
        #endregion


                 
        #region Dictionary-Einträge  - Dic. in ini-Datei schreiben; eine vorhandene Datei wird ueberschrieben 
        public bool IniWriteAll_FromDictionary_IntoFile()
        {
            bool ret=DelIniFile();
            if(ret==true)
            {
                try
                {
                    foreach(KeyValuePair<string[] , string> d in my_DIC.INI_Dictionary)
                    {
                        if(d.Key[0]==d.Key[1])
                        {
                            d.Key[1]="";
                            
                        }
                       this.IniWriteValue(d.Key[0] , d.Key[1] , d.Value);
                    }
                }
                catch(Exception ex)
                {

                    throw new Exception("error in IniWriteAll_FromDictionary_IntoFile: \n\n"+ex.Message);
                }

            }
            return ret;
        }
        #endregion

        #region Dictionary-Einträge - Dic. in xml-Datei schreiben; eine vorhanende Datei  wird ueberschrieben
        public bool IniWriteAll__IntoXmlFile(string rootName)
        {
            bool ret=false;
            int i=0;
            int j=0;
            int k=0;
           
            string[] split1=new string[2];
            string[] split2=new string[2];
            Dictionary<string , string> retListe=new Dictionary<string , string>(1);

            // ini-datei komplett einlesen
            try
            {
                string[] liste=File.ReadAllLines(INI_FILE);
                if(liste.Length<=0)
                {
                    ret=false;
                    throw new Exception("\nFile: "+INI_FILE+" not found or empty");
                }
                object[] o=new object[liste.Length];
                object[] o2=new object[liste.Length];


                foreach(string s in liste)
                {

                    if(s[0]=='[' && string.IsNullOrEmpty(s)==false)
                    {
                        split1.Initialize();
                        split2.Initialize();
                        split1=s.Split('[');
                        split2=split1[1].Split(']');
                        
                        IniReadAll_fromFile_intoDictionary(split2[0].ToString() , INI_READ_MOD_.ONLY_ONE_SECTION);

                        i=0;
                        for(j=0 ; j<o.Length ; j++)
                            o.SetValue("" , j);
                        foreach(KeyValuePair<string[] , string> d in my_DIC.INI_Dictionary)
                        {

                            o.SetValue(new XElement(d.Key[1] , d.Value) , i);
                            i++;
                            //MessageBox.Show("ALL -> "+"[Key= "+d.Key+"    value= "+d.Value+"]");
                        }
                        o2.SetValue(new XElement(split2[0].ToString() , o) , k);
                        k++;
                    }
                   
                }

                XElement xml = new XElement(rootName , o2);
                xml.Save(XML_FILE);
                ret=true;
            }
            catch(Exception ex)
            {
                ret=false;
            }
           
             
           return ret;
        }
        #endregion



        // ---------------------------------------------------------------------------------------------------------
      
        ///   Dictionary Klasse - cDic  
        ///
        /// - . Dictionary - vier Funktionen zum Arbeiten - myInstanz.myDIC.func
        ///  .func:
        /// - myInstanz.my_DIC.myAdd("SECTION_1" , "Key1" , "value"); // den Eintrag ins Dictionary schreiben; wenn nicht bereits vorhanden
        /// - myInstanz.my_DIC.myRemove("SECTION_1" , "Key2");        // den Eintrag aus Dictionary loeschen; wenn vorhanden
        /// - string myValue=myInstanz.my_DIC.myGetValue("SECTION_2" , "Key1"); // Value des Eintrags holen; wenn vorhanden
        /// - myInstanz.my_DIC.mySetValue("SECTION_2" , "Key1","newValue");     // Value des Eintrags neu setzen; wenn Eintrag vorhanden  
        ///

        #region eigene Dictionary Klasse
            /// <summary>
            /// 
            /// Funktionen:
            /// 
            /// </summary>
            public class cDic : Dictionary<string[],string>
            {

                #region eigenschaften ect.
                // hier werden die Daten abgelegt
                private Dictionary<string[] , string> key_Dictionary=new Dictionary<string[] , string>(1);
                public Dictionary<string[] , string> INI_Dictionary
                {
                    private set
                    {
                        key_Dictionary=value;
                    }
                    get
                    {
                        return key_Dictionary;
                    }
                }
                #endregion


                #region anlegen Eintrag in Dic. ;mit Prüfung ob bereits vorhanden !!!
                /// <summary>
                /// ADD -> wenn Eintrag nicht vorhanden  ansonsten  false
                /// </summary>
                /// <param name="Sektion"></param>
                /// <param name="Key"></param>
                /// <param name="Value"></param>
                /// <returns>bool</returns>
                public bool myAdd(string Sektion, string Key , string Value )
                {
                    bool ret=false;
                    bool found=false;

                    if(!(string.IsNullOrEmpty(Sektion)==true && string.IsNullOrEmpty(Key)==true ))
                    {
                        // erst prüfen ob Eintrag vorhanden ist
                        foreach(string[] s in INI_Dictionary.Keys)
                        {
                            //        _key=Sectionname + Key                     ,           Value   
                            //             Sectionname       -        Key        -           Value
                            //MessageBox.Show(d.Key[0]+" -> "+"Key= ["+d.Key[1]+"]   value= ["+d.Value+"]");
                            if(s[0]==Sektion && s[1]==Key)
                            {
                                found=true;
                                break;
                            }
                        }

                        // wenn Eintrag nicht vorhanden ... ADD
                        if(found==false)
                        {
                           
                            string[] _mergedkey=new string[2] { Sektion , Key };
                            INI_Dictionary.Add(_mergedkey , Value);
                            //MessageBox.Show(Key[0]+" " + Key[1]+"  "+Value);
                            ret=true;
                        }
                    }            
                    return ret;
                }
                #endregion


                #region  loeschen Eintrag in Dic. 
                public bool myRemove( string Sektion , string Key )
                {
                    bool ret=false;
                    bool found=false;
                    string[] _mergedkey=new string[2] { "" , "" };


                    if(!(string.IsNullOrEmpty(Sektion)==true && string.IsNullOrEmpty(Key)==true))
                    {
                        // erst prüfen ob Eintrag vorhanden ist
                        foreach(string[] s in INI_Dictionary.Keys)
                        {

                            //        _key=Sectionname + Key                     ,           Value   
                            //             Sectionname       -        Key        -           Value
                            //MessageBox.Show(d.Key[0]+" -> "+"Key= ["+d.Key[1]+"]   value= ["+newValue+"]");
                            if(s[0]==Sektion && s[1]==Key)
                            {
                                found=true;
                                _mergedkey=s;
                                break;
                            }
                        }


                        // wenn Eintrag nicht vorhanden ... ADD
                        if(found==true)
                        {

                            ret=INI_Dictionary.Remove(_mergedkey);

                        }
                    }
                    return ret;
                }
                #endregion


                #region ändern -Value-  eines vorhanden Eintrags in Dic. 
                public bool mySetValue( string Sektion , string Key , string newValue )
                {
                    bool ret=false;
                    bool found=false;
                    string[] _mergedkey=new string[2] { "" , "" };


                    if(!(string.IsNullOrEmpty(Sektion)==true && string.IsNullOrEmpty(Key)==true))
                    {
                        // erst prüfen ob Eintrag vorhanden ist
                        foreach(string[] s in INI_Dictionary.Keys)
                        {

                            //        _key=Sectionname + Key                     ,           Value   
                            //             Sectionname       -        Key        -           Value
                            //MessageBox.Show(d.Key[0]+" -> "+"Key= ["+d.Key[1]+"]   value= ["+newValue+"]");
                            if(s[0]==Sektion && s[1]==Key)
                            {
                                found=true;
                                _mergedkey=s;
                                break;
                            }
                        }


                        // wenn Eintrag nicht vorhanden ... ADD
                        if(found==true)
                        {

                            INI_Dictionary[_mergedkey] =newValue;
                            ret=true;
                        }
                    }
                    return ret;
                }
                #endregion


                #region Value eines Eintrages  holen
                /// <summary>
                /// Wenn im dic. Section/Key vorhanden -> return value   ansonsten NULL
                /// </summary>
                /// <param name="Sektion"></param>
                /// <param name="Key"></param>
                /// <returns></returns>
                public string myGetValue( string Sektion , string Key )
                {
                    string ret="";
                    bool found=false;
                    string[] _mergedkey=new string[2] { "" , "" };
                    
                    if(!(string.IsNullOrEmpty(Sektion)==true && string.IsNullOrEmpty(Key)==true))
                    {
                        // erst prüfen ob Eintrag vorhanden ist
                        foreach(string[] s in INI_Dictionary.Keys)
                        {

                            //        _key=Sectionname + Key                     ,           Value   
                            //             Sectionname       -        Key        -           Value
                            //MessageBox.Show(d.Key[0]+" -> "+"Key= ["+d.Key[1]+"]   value= ["+newValue+"]");
                            if(s[0]==Sektion && s[1]==Key)
                            {
                                found=true;
                                _mergedkey=s;
                                break;
                            }
                        }


                        // wenn Eintrag nicht vorhanden ... ADD
                        if(found==true)
                        {

                            ret=INI_Dictionary[_mergedkey].ToString();
                        }
                    }


                    return ret;
                }
                #endregion

            }// end class cDic
        #endregion

        // ----------------------------------------------------------------------------------------------------------

    }// end class iniFile
    #endregion

Kommentare zum Snippet

 

Logge dich ein, um hier zu kommentieren!