Fra string( hex numre fra en mac addr) til byte[6]

using System;
using System.Collections.Generic;
using System.Text;

namespace e719017
{
    class Program
    {
        static void Main(string[] args)
        {
            string macStr = "00137218ECB2";

            // Konversion fra hex til decimal.
            Int64 macInt = Int64.Parse(macStr, System.Globalization.NumberStyles.HexNumber);

            // Konversion til byte-array.
            byte[] macByte = new byte[6];
            for (int pos = 5; pos >= 0; pos--)
            {
                macByte[pos] = (byte) (macInt % 256);
                macInt /= 256;
            }

            // Udskrivning.
            for (int pos = 0; pos < 6; pos++)
            {
                Console.WriteLine(macByte[pos]);
            }
        }
    }
}

eller som i

using System;
using System.Globalization;

namespace E
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            string macstr = "00137218ECB2";
            ulong macint = ulong.Parse(macstr, NumberStyles.HexNumber);
            byte[] macbyt8 = BitConverter.GetBytes(macint);
            foreach(byte b in macbyt8) Console.Write(" " + b);
            Console.WriteLine();
            byte[] macbyt6 = new byte[6];
            Array.Copy(macbyt8, macbyt6, 6);
            Array.Reverse(macbyt6);
            foreach(byte b in macbyt6) Console.Write(" " + b);
            Console.WriteLine();
        }
    }
}

johhhh, kan godt se at begge virker... men hvad er det præcist der lige sker og hvorfor....

Måderne ligner jo tildels hinanden med små ændringer

I må begge gerne ligge et svar, selvom der ikke gives en mere uddybende forklaring, da det er jo svar....

// ouT

vi parser begge strengen til en 64 bit integer i et hug fremfor at
parse 2 byte af gangen som i din originale kode

nielle henter så 6 bytes ud af den 64 bit integer i en for loop

jeg bruger BitConverter klassen til at hente 8 byte ud i et array
og fisker så de relevante 6 byte ud af det

generelt ville jeg nok gøre det som i din originale kode fordi den kan
nemt modificeres til at håndtere bindestreger i adressen

mit forslag er ikke på mange linier, men er faktisk mere klodset end nielles fordi
data skal kopieres en ekstra gang fra de 8 til de 6 bytes

mit forslag er derfor mest relevant hvis du kan bruge macbyt8 direkte

som i:

using System;
using System.Globalization;

namespace E
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            string macstr = "00137218ECB2";
            ulong macint = ulong.Parse(macstr, NumberStyles.HexNumber);
            byte[] macbyt8 = BitConverter.GetBytes(macint);
            for(int i = 5; i >= 0; i--) Console.Write(" " + macbyt8[i]);
            Console.WriteLine();
            byte[] macbyt6 = new byte[6];
            Array.Copy(macbyt8, macbyt6, 6);
            Array.Reverse(macbyt6);
            foreach(byte b in macbyt6) Console.Write(" " + b);
            Console.WriteLine();
        }
    }
}

og et svar

Vi starter med MAC adressen på dens hexadecimale form:

            string macStr = "00137218ECB2";

Først konverteres det til decimalform:

            Int64 macInt = Int64.Parse(macStr, System.Globalization.NumberStyles.HexNumber);

For at der skal "være" plads nok, bruger jeg en Int64 (= long) i stedet for en int (= Int32). Kunne også have brugt ulong som Arne_v (egentlig et mere naturligt valg idet der jo aldrig kan blive tale om et negativt tal alligevel). Den decimale værdi er i dette tilfælde: 83518614706.

For at konvertere MAC-adressen til dens byte-form er det centralt at vide at repræsentationen ”0 19 114 24 236 178” skal læses som tallet:

0*256^5 + 19*256^4 + 114*256^3 + 24*256^2 + 236*256^1 + 178*256^0

hvilket altså er 83518614706.

Det er det som den følgende løkke udnytter:

            // Konversion til byte-array.
            byte[] macByte = new byte[6];
            for (int pos = 5; pos >= 0; pos--)
            {
                macByte[pos] = (byte) (macInt % 256);
                macInt /= 256;
            }

Jeg har valgt at lægge værdierne i byte-arrayet i denne rækkefølge:

(0, 19, 114, 24, 236, 178)

En anden, og faktisk mere naturlig måde indenfor programmering, ville være denne form:

(178, 236, 24, 114, 19, 0)

For at finde de enkelte bytes i tallet 83518614706, benytter jeg dels ”%” (modulus, eller ”resten af division med”), og dels ”/” som i dette tilfælde er heltalsdivision (fordi at ingen af dividenderne er floats).

Værdien af:

83518614706 % 256

er lig med ”resten af 83518614706 ved division med 256”. I dette tilfælde giver det os værdien 178 som er det ”ciffer” som ligger længst til højre i byte-arrayet:

Efter at have fundet “cifret” via %, divideres der med 256 (husk at ”macInt /= 256” skal læses som ”macInt = macInt / 256”). Formålet med dette er at reducere tallet – populært sagt at smide 256-potensen yderst til højre væk. I alt ser det nogenlunde sådan her ud:

Vi starter med:

macInt = 83518614706 = 0*256^5 + 19*256^4 + 114*256^3 + 24*256^2 + 236*256^1 + 178*256^0

1. gennemløb:

pos = 5
macByte[5] = (byte) (macInt % 256);  // = 178
macInt /= 256;  // = 0*256^4 + 19*256^3 + 114*256^2 + 24*256^1 + 236*256^0

2. gennemløb:

pos = 4
macByte[4] = (byte) (macInt % 256);  // = 236
macInt /= 256;  // = 0*256^3 + 19*256^2 + 114*256^1 + 24*256^0

3. gennemløb:

pos = 3
macByte[3] = (byte) (macInt % 256);  // = 24
macInt /= 256;  // = 0*256^2 + 19*256^1 + 114*256^0

4. gennemløb:

pos = 2
macByte[2] = (byte) (macInt % 256);  // = 114
macInt /= 256;  // = 0*256^1 + 19*256^0

5. gennemløb:

pos = 1
macByte[1] = (byte) (macInt % 256);  // = 19
macInt /= 256;  // = 0*256^0

6. gennemløb:

pos = 0
macByte[0] = (byte) (macInt % 256);  // = 0
macInt /= 256;  // = 0

Den allersidste løkke skriver tallet ud:

            // Udskrivning.
            for (int pos = 0; pos < 6; pos++)
            {
                Console.WriteLine(macByte[pos]);
            }

Håber at det var til at forstå? Ellers må du jo spørge.

og et svar