Feedback

C# - Zahlensysteme (BIN, HEX, OCT, DEZ) umrechnen

Veröffentlicht von am 02.10.2010
(21 Bewertungen)

Diese Klasse stellt eine Funktion (static) zum Umrechnen von einem Zahlensystem in ein anderes.
z.Z: BINAR,HEX,OCTAL und DEZIMAL ....


Klasse: cFromInZahlenSystem

STATIC-
Funktion: cFromInZahlenSystem.umrechnenZahl( (object)von_zahl , von_zahl_system , in_neues_Zahlensystem);

von_zahl_system und in_neues_zahlensystem=BINAER,OCTAL,HEX,DEZIMAL->cFromInZahlenSystem.ZAHLENSYSTEM.value;

Rueckgabe bzw. Ergebnis in Member: cFromInZahlenSystem.IN_ZAHL_ERGEBNIS; // as OBJECT

Beispiele:
----------
// die Zahl "100" Binaer in Dezimal
cFromInZahlenSystem.umrechnenZahl( (object)"100" , 2 , 10);
// oder alternativ...
cFromInZahlenSystem.umrechnenZahl( (object)"100" ,cFromInZahlenSystem.ZAHLENSYSTEM.BINAER , cFromInZahlenSystem.ZAHLENSYSTEM.DEZIMAL );
// Ergebnis in TextBox = 4
textbox-Text=Convert.ToSting(cFromInZahlenSystem.IN_ZAHL_ERGEBNIS);


// die Zahl "FF" Hexa in Dezimal
cFromInZahlenSystem.umrechnenZahl( (object)"FF" , 16 , 10);
// Ergebnis in TextBox = 255
textbox-Text=Convert.ToSting(cFromInZahlenSystem.IN_ZAHL_ERGEBNIS);
// oder alternativ...
cFromInZahlenSystem.umrechnenZahl( (object)"100" ,cFromInZahlenSystem.ZAHLENSYSTEM.HEXA , cFromInZahlenSystem.ZAHLENSYSTEM.DEZIMAL );

// die Zahl 16 Dezimal in Binaer
cFromInZahlenSystem.umrechnenZahl( (object)16 , 10 , 2);
// Ergebnis in TextBox = "10"
textbox-Text=Convert.ToSting(cFromInZahlenSystem.IN_ZAHL_ERGEBNIS);
// oder alternativ...
cFromInZahlenSystem.umrechnenZahl( (object)"100" ,cFromInZahlenSystem.ZAHLENSYSTEM.DEZIMAL , cFromInZahlenSystem.ZAHLENSYSTEM.BINAER );

// usw....


Weiter Dokumentation im Source.
(siehe Zusatzfunktion: ComboBox - Abfrage - einbinden )

#region Umrechnung von einem Zahlensystem in ein anderes... z.Z werden Ausgewertet: BINAER,OCTAL,DEZIMAL und HEXDEZIMAL...
    //class: cFromInZahlenSystem  -  static !!!!
    //
    // Aufruf1 ohne ComboBox:
    //                            cFromInZahlenSystem.umrechnenZahl((object)von_zahl , von_zahl_system , in_neues_Zahlensystem);
    // Ergebnis steht dann als:   cFromInZahlenSystem.IN_ZAHL_ERGEBNIS;  // ACHTUNG as OBJECT !!!
    //
    //
    // Aufruf2 mit ComboBox-Auswertung (muss dann natuerlich vorhanden sein !!!):
    //    
    //                                       cFromInZahlenSystem.umrechnenZahl((object)von_zahl , ZAHLENSYSTEM.value , ZAHLENSYSTEM.value );
    // Ergebnis steht dann als (objekt) in : cFromInZahlenSystem.IN_ZAHL_ERGEBNIS;
    //
    // oder   :        ergebnis(as STRING) = cFromInZahlenSystem.umrechnenZahl((object)von_zahl , ZAHLENSYSTEM.value , ZAHLENSYSTEM.value );
    // Ergebnis steht natuerlich auch hier in:  cFromInZahlenSystem.IN_ZAHL_ERGEBNIS;  // ACHTUNG as OBJECT !!!
    public class cFromInZahlenSystem
    {

        private cFromInZahlenSystem() { }

        // Eigenschaften
        public enum ZAHLENSYSTEM { BINAER=2 , OKTAL=8 , DEZIMAL=10 , HEXA=16 };


        /// <summary>für eine evt. ComboBox !!! Datenbindung in Form_load:   meine_comboBox.DataSource=cFromInZahlenSystem.ComboBoxListe;
        ///     "von DEC in BIN"   ,
        ///     "von DEC in OCT"  ,
        ///     "von DEC in HEX"    ,
        ///     "-----------------------" ,
        ///     "von BIN in DEC"   ,
        ///     "von OCT in DEC"   ,
        ///     "von HEX in DEC"   ,
        ///     "-----------------------" ,
        ///     "von BIN in OCT"  ,
        ///     "von HEX in OCT"   ,
        ///     "-----------------------" ,
        ///     "von BIN in HEX"   ,
        ///     "von OCT in HEX"  ,
        ///     "-----------------------" ,
        ///     "von OCT in BIN"  ,
        ///     "von HEX in BIN"  ,
        ///     "-----------------------" 
        /// </summary>

        // Die Belegung ihrer ComobBox nach Datenbindung !!!
        public static object[] ComboBoxListe = new object[] { 
             "von DEC in BIN"   ,
             "von DEC in OCT"  ,
             "von DEC in HEX"    ,
             "-----------------------" ,
             "von BIN in DEC"   ,
             "von OCT in DEC"   ,
             "von HEX in DEC"   ,
             "-----------------------" ,
             "von BIN in OCT"  ,
             "von HEX in OCT"   ,
             "-----------------------" ,
             "von BIN in HEX"   ,
             "von OCT in HEX"  ,
             "-----------------------" ,
             "von OCT in BIN"  ,
             "von HEX in BIN"  ,
             "-----------------------" 
        };

        private static object VON_ZAHL
        {
            get;
            set;
        }
        public static object IN_ZAHL_ERGEBNIS
        {
            get;
            private set;
        }

        private static int VON_ZAHLENSYSTEM
        {
            get;
            set;
        }
        private static int IN_ZAHLENSYSTEM
        {
            get;
            set;
        }

        // 1. Moeglichkeit:  Umrechnen von einen Zahlensystem in ein anderes
        //
        // Aufruf:  ergebnis(as STRING) = cFromInZahlenSystem.umrechnenZahl((object)von_zahl , ZAHLENSYSTEM.value , ZAHLENSYSTEM.value );
        // Ergebnis steht natuerlich auch hier in:  cFromInZahlenSystem.IN_ZAHL_ERGEBNIS;  // ACHTUNG as OBJECT !!!        
        // Achtung nur ZAHLENSYSTEM { BINAER=2 , OKTAL=8 , DEZIMAL=10 , HEXA=16 } z.Z. zugelassen !!!
        public static void umrechnenZahl( object vonZahl , ZAHLENSYSTEM von_Zahlensystem , ZAHLENSYSTEM in_Zahlensystem )
        {

            if(vonZahl.ToString().Length<=0)
                throw new FormatException("Fehler 1a:   bitte eine Zahl eingeben ");


            VON_ZAHL=vonZahl;

            VON_ZAHLENSYSTEM= von_Zahlensystem.GetHashCode();
            IN_ZAHLENSYSTEM=in_Zahlensystem.GetHashCode();

            berechnung();


        }

        // 2. Moeglichkeit:  Umrechnen von einen Zahlensystem in ein anderes
        //
        // Aufruf:  cFromInZahlenSystem.umrechnenZahl((object)von_zahl ,(int) von_zahl_system ,(int) in_neues_Zahlensystem);
        // Ergebnis steht dann in:   cFromInZahlenSystem.IN_ZAHL_ERGEBNIS;   // ACHTUNG as OBJECT !!!
        // Achtung nur ZAHLENSYSTEM { BINAER=2 , OKTAL=8 , DEZIMAL=10 , HEXA=16 } z.Z. zugelassen !!!
        public static void umrechnenZahl( object vonZahl , int von_Zahlensystem , int in_Zahlensystem )
        {

            if(vonZahl.ToString().Length<=0)
                throw new FormatException("Fehler 2a:   bitte eine Zahl eingeben ");


            VON_ZAHL=vonZahl;
            if(!((von_Zahlensystem == ZAHLENSYSTEM.BINAER.GetHashCode()) || (von_Zahlensystem == ZAHLENSYSTEM.DEZIMAL.GetHashCode()) || (von_Zahlensystem == ZAHLENSYSTEM.HEXA.GetHashCode()) || (von_Zahlensystem == ZAHLENSYSTEM.OKTAL.GetHashCode())))
                throw new FormatException("Fehler 2b:   bitte  von_welchem_ZahlSystem  eingeben  ->(2,8,10,16)");

            VON_ZAHLENSYSTEM=von_Zahlensystem;

            if(!((in_Zahlensystem == ZAHLENSYSTEM.BINAER.GetHashCode()) || (in_Zahlensystem == ZAHLENSYSTEM.DEZIMAL.GetHashCode()) || (in_Zahlensystem == ZAHLENSYSTEM.HEXA.GetHashCode()) || (in_Zahlensystem == ZAHLENSYSTEM.OKTAL.GetHashCode())))
                throw new FormatException("Fehler 2c:   bitte  in_welches_neue_ZahlSystem  eingeben   ->(2,8,10,16)");
            IN_ZAHLENSYSTEM=in_Zahlensystem;

            berechnung();


        }


        private static void berechnung()
        {
            // von Binaer....
            if(VON_ZAHLENSYSTEM==2)
            {
                switch(IN_ZAHLENSYSTEM)
                {
                    case 2:
                        IN_ZAHL_ERGEBNIS=(object) (Convert.ToString((Convert.ToUInt32(VON_ZAHL)) , 2).PadLeft(32 , '0'));
                        break;
                    case 8:
                        BinToDec();
                        VON_ZAHL=IN_ZAHL_ERGEBNIS;
                        DecToOct();
                        break;
                    case 10:
                        BinToDec();
                        break;
                    case 16:
                        BinToDec();
                        VON_ZAHL=IN_ZAHL_ERGEBNIS;
                        DecToHex();
                        break;
                    default:
                        break;
                }
            }

            // von Octal....
            if(VON_ZAHLENSYSTEM==8)
            {
                switch(IN_ZAHLENSYSTEM)
                {
                    case 2:
                        OctToDec();
                        VON_ZAHL=IN_ZAHL_ERGEBNIS;
                        DecToBin();
                        break;
                    case 8:
                        IN_ZAHL_ERGEBNIS=VON_ZAHL;
                        break;
                    case 10:
                        OctToDec();
                        break;
                    case 16:
                        OctToDec();
                        VON_ZAHL=IN_ZAHL_ERGEBNIS;
                        DecToHex();
                        break;
                    default:
                        break;
                }
            }

            //von DEC........
            if(VON_ZAHLENSYSTEM==10)
            {
                switch(IN_ZAHLENSYSTEM)
                {
                    case 2:
                        DecToBin();
                        break;
                    case 8:
                        DecToOct();
                        break;
                    case 10:
                        IN_ZAHL_ERGEBNIS=VON_ZAHL;
                        break;
                    case 16:
                        DecToHex();
                        break;
                    default:
                        break;
                }
            }


            //von HEX........
            if(VON_ZAHLENSYSTEM==16)
            {
                switch(IN_ZAHLENSYSTEM)
                {
                    case 2:
                        HexToDec();
                        VON_ZAHL=IN_ZAHL_ERGEBNIS;
                        DecToBin();
                        break;
                    case 8:
                        HexToDec();
                        VON_ZAHL=IN_ZAHL_ERGEBNIS;
                        DecToOct();
                        break;
                    case 10:
                        HexToDec();
                        break;
                    case 16:
                        IN_ZAHL_ERGEBNIS=VON_ZAHL;
                        break;
                    default:
                        break;
                }
            }



        }


        // Dezimal in Binaer
        private static void DecToBin()
        {

            IN_ZAHL_ERGEBNIS= (object) (Convert.ToString((Convert.ToUInt32(VON_ZAHL)) , 2).PadLeft(32 , '0'));

        }
        private static void DecToOct()
        {

            IN_ZAHL_ERGEBNIS= (object) (Convert.ToString((Convert.ToUInt32(VON_ZAHL)) , 8).PadLeft(32 , '0'));

        }
        // Dezimal nach Hexadezimal
        private static void DecToHex()
        {
            IN_ZAHL_ERGEBNIS= (object) (string.Format("{0:x}" , Convert.ToInt16(Convert.ToString(VON_ZAHL))));
        }



        // Binaer in dezimal
        private static void BinToDec()
        {
            IN_ZAHL_ERGEBNIS= (object) (Convert.ToUInt64((string) VON_ZAHL , 2));

        }
        // Octal in dezimal
        private static void OctToDec()
        {
            IN_ZAHL_ERGEBNIS= (object) (Convert.ToUInt64((string) VON_ZAHL , 8));

        }
        // Hexadezimal nach Dezimal
        private static void HexToDec()
        {
            //IN_ZAHL_ERGEBNIS= (object)(Int32.Parse((string)VON_ZAHL , System.Globalization.NumberStyles.HexNumber));
            IN_ZAHL_ERGEBNIS= (object) (Convert.ToInt64((string) VON_ZAHL , 16));


        }

        // hier die ComboBox auswerten...
        // z.B.:
        // Bed.:  Es muss natuerlich vorher eine ComboBox angelegt worden sein und zwei TextBoxes - eine für die Zahl und eine fuer das Ergebnis
        //                                                                           
        // 1.Im eigenen Source folgende Zeile einbinden z.B. in Form_Load:  
        //   private void myForm_Load( object sender , EventArgs e )
        //   {
        //    
        //     eigencomboBox.DataSource=cFromInZahlenSystem.ComboBoxListe;  // Datenbindung an ihre ComboBox !!!
        //     //....
        //   }
        //   
        //                                              
        // 2.Auswerten der ComboBox im eigenen Source: 
        //
        //   WICHTIG;  in SelectedIndexChanged-Funktion ihrer ComboBox !!!
        //
        //   private void eigencomboBox_SelectedIndexChanged( object sender , EventArgs e )
        //   {
        //    try
        //    {
        //        meine_textbox_Ergebnis.Text="";  // z.B:  hier die eigene TextBox fuer das Ergebnis   
        //        meine_textbox_Ergebnis.Text = cFromInZahlenSystem.auswerten_comboBox_SelectedIndexChanged( eigencomboBox.SelectedIndex, (object)meine_textbox_vonZahl.Text );
        //        // oder  meine_textbox_Ergebnis.Text = Convert.ToString(cFromInZahlenSystem.IN_ZAHL_ERGEBNIS); 
        //    }
        //    catch(FormatException ex)
        //    {
        //        MessageBox.Show(ex.Message);
        //    }
        //    catch(Exception ex)
        //    {
        //        MessageBox.Show(ex.Message);
        //    }
        //   }

        // Eingabe:    SelectedIndex ihre eigenenComboBox(int) ,  der umzurechnende Wert(als OBJECT)  
        // Rueckgabe:  ergebnis (als STRING)
        // Beispiel :  meine_textbox_Ergebnis.Text = cFromInZahlenSystem.auswerten_comboBox_SelectedIndexChanged( eigencomboBox.SelectedIndex, (object)meine_textbox_vonZahl.Text );
        public static string auswerten_comboBox_SelectedIndexChanged(int index,  object value  )
        {
            string s=null;
            
            // Die Belegung ihrer CombBox nach Datenbindung !!!
            //von DEC in BIN   =0
            //von DEC in OCT   =1
            //von DEC in HEX   =2
            //-----------------------
            //von BIN in DEC   =4
            //von OCT in DEC   =5
            //von HEX in DEC   =6
            //-----------------------
            //von BIN in OCT   =8
            //von HEX in OCT   =9
            //-----------------------
            //von BIN in HEX   =11
            //von OCT in HEX   =12
            //-----------------------
            //von OCT in BIN   =14
            //von HEX in BIN   =15
            //-----------------------
            try
            {
                
                switch(index)
                {
                    case 0:
                        
                        umrechnenZahl((object) value , ZAHLENSYSTEM.DEZIMAL , ZAHLENSYSTEM.BINAER);
                        break;
                    case 1:
                        umrechnenZahl((object) value , ZAHLENSYSTEM.DEZIMAL , ZAHLENSYSTEM.OKTAL);
                        break;
                    case 2:
                        umrechnenZahl((object) value , ZAHLENSYSTEM.DEZIMAL , ZAHLENSYSTEM.HEXA);
                        break;
                    case 4:
                        umrechnenZahl((object) value , ZAHLENSYSTEM.BINAER , ZAHLENSYSTEM.DEZIMAL);
                        break;
                    case 5:
                        umrechnenZahl((object) value , ZAHLENSYSTEM.OKTAL , ZAHLENSYSTEM.DEZIMAL);
                        break;
                    case 6:
                        umrechnenZahl((object) value , ZAHLENSYSTEM.HEXA , ZAHLENSYSTEM.DEZIMAL);
                        break;
                    case 8:
                        umrechnenZahl((object) value , ZAHLENSYSTEM.BINAER , ZAHLENSYSTEM.OKTAL);
                        break;
                    case 9:
                        umrechnenZahl((object) value , ZAHLENSYSTEM.HEXA , ZAHLENSYSTEM.OKTAL);
                        break;
                    case 11:
                        umrechnenZahl((object) value , ZAHLENSYSTEM.BINAER , ZAHLENSYSTEM.HEXA);
                        break;
                    case 12:
                        umrechnenZahl((object) value , ZAHLENSYSTEM.OKTAL , ZAHLENSYSTEM.HEXA);
                        break;
                    case 14:
                        umrechnenZahl((object) value , ZAHLENSYSTEM.OKTAL , ZAHLENSYSTEM.BINAER);
                        break;
                    case 15:
                        umrechnenZahl((object) value , ZAHLENSYSTEM.HEXA , ZAHLENSYSTEM.BINAER);
                        break;

                    default:

                        break;

                }
                s = Convert.ToString(IN_ZAHL_ERGEBNIS);
              
               
            }
            catch(FormatException ex)
            {
                s=null;
                MessageBox.Show(ex.Message);
            }
            catch(Exception ex)
            {
                s=null;
                MessageBox.Show(ex.Message);
            }

           return s;
        }


    }
    #endregion

2 Kommentare zum Snippet

A,Roters schrieb am 26.11.2010:
super
hl2mukkel schrieb am 21.04.2011:
Klasse, aber
Convert.ToString(zahl, (2,8,10 oder 16))

geht auch ;o)
 

Logge dich ein, um hier zu kommentieren!