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
// 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!