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 )

GFU-Schulungen  [Anzeige]

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.

VB.NET Aufbau

Sie verfügen nach der Schulung über fundierte Kenntnisse in der Arbeit mit objektorientierten Modellen in VB.NET und können wiederverwendbare Komponenten eigenständig erzeugen.

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