MAC-Adresse auslesen und spoolen

6 Kommentare

1. Kurze Alternative zu public bool get_mac
   [code]
   public static bool check_mac(string macadresse)
   {
   long converted;
   bool macOkay = true;
   if (long.TryParse(macadresse.Replace(„:“, string.Empty), NumberStyles.HexNumber, CultureInfo.InvariantCulture.NumberFormat,
   out converted) && macadresse.Length == 17)
   {
   if (macadresse.Split(‚:‘).Any(macpart => macpart.Length != 2))
   {
   macOkay = false;
   }
   }
   else
   {
   macOkay = false;
   }
   return macOkay;
   }
   [/code]

2. @SteeW Deine Variante funktioniert wahrscheinlich (nicht getestet), braucht aber deutlich mehr Leistung als die Variante von Tera3yte. Wenn dir die originale Methode trotzdem zu lang ist, es geht auch anders:
   [code]public static bool check_mac(string macadresse)
   {
   if (macadresse.Length != 17)
   return false;
   for (int i = 0; i < macadresse.Length; ++i) { if (i % 3 == 2) { if (macadresse[i] != ':') return false; } else if ((macadresse[i] >= ‚0‘ && macadresse[i] <= '9') || (macadresse[i] >= ‚a‘ && macadresse[i] <= 'f') || (macadresse[i] >= ‚A‘ && macadresse[i] <= 'F')) return false; } return true; }[/code]

3. @Koopakiller Deine Variante ist gemessen die schnellste. Gefällt mir sehr gut.
   Eine ganz kurze (Code) aber ebenfalls leistungshungrige Variante wäre noch:
   [code]
   public static bool check_mac(string macadresse)
   {

   if (Regex.IsMatch(macadresse, @“^(?:([da-f]{2}):){5}[da-f]{2}$“, RegexOptions.IgnoreCase))
   return true;

   return false;
   }
   [/code]

4. @SteeW: Die Schnellste wäre bis dato deine letzte Version
   ticks: [original: 1190 | deine 1. Version: 1954 | Koopakiller: 1282 | deine 2. Version (Regex): 561]

   Wenn der Regex Ausdruck ausgelagert wird:
   [code]
   private static Regex MacCheckRegex = new Regex(@“^(?:[0-9A-F]{2}[:-]){5}(?:[0-9A-F]{2})$“, RegexOptions.IgnoreCase);
   public bool check_mac(string macadresse)
   {
   return MacCheckRegex.IsMatch(macadresse);
   }
   [/code]
   verkürzt sich die Zeit auf ca. 360 ticks

5. @mcjoin Du solltest die Messung lieber mit einer Schleife wiederhohlen. Nur eine einzige Ausführung sagt wenig über die Ergebnisse aus.
   Ich habe den Test nochmal mit folgendem Code wiederhohlt:
   [code]class Program
   {
   static void Main(string[] args)
   {
   var macs = new List();
   Random rnd = new Random();
   for (int i = 0; i < 10000000; ++i) { var bytes = new byte[6]; rnd.NextBytes(bytes); macs.Add(string.Format("{0:X}:{1:X}:{2:X}:{3:X}:{4:X}:{5:X}", bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5])); } Stopwatch sw = new Stopwatch(); sw.Start(); foreach (var mac in macs) check_mac1(mac); sw.Stop(); Console.WriteLine("Original: " + sw.ElapsedMilliseconds); sw.Reset(); sw.Start(); foreach (var mac in macs) check_mac2(mac); sw.Stop(); Console.WriteLine("als long: " + sw.ElapsedMilliseconds); sw.Reset(); sw.Start(); foreach (var mac in macs) check_mac3(mac); sw.Stop(); Console.WriteLine("Koopakiller: " + sw.ElapsedMilliseconds); sw.Reset(); sw.Start(); foreach (var mac in macs) check_mac4(mac); sw.Stop(); Console.WriteLine("Regex: " + sw.ElapsedMilliseconds); sw.Reset(); sw.Start(); foreach (var mac in macs) check_mac5(mac); sw.Stop(); Console.WriteLine("static Regex: " + sw.ElapsedMilliseconds); sw.Reset(); Console.ReadKey(); } public static bool check_mac1(string macadresse) { bool macOkay = false; if (macadresse.Length == 17) { for (int i = 0; i < macadresse.Length; i++) { switch (macadresse[i]) { case '0': macOkay = true; break; case '1': macOkay = true; break; case '2': macOkay = true; break; case '3': macOkay = true; break; case '4': macOkay = true; break; case '5': macOkay = true; break; case '6': macOkay = true; break; case '7': macOkay = true; break; case '8': macOkay = true; break; case '9': macOkay = true; break; case 'A': macOkay = true; break; case 'B': macOkay = true; break; case 'C': macOkay = true; break; case 'D': macOkay = true; break; case 'E': macOkay = true; break; case 'F': macOkay = true; break; case ':': macOkay = true; break; default: macOkay = false; break; } if (i % 3 == 2) { if (macadresse[i] != ':') { macOkay = false; } } if (!macOkay) { return macOkay; } } } return macOkay; } public static bool check_mac2(string macadresse) { long converted; bool macOkay = true; if (long.TryParse(macadresse.Replace(":", string.Empty), NumberStyles.HexNumber, CultureInfo.InvariantCulture.NumberFormat, out converted) && macadresse.Length == 17) { if (macadresse.Split(':').Any(macpart => macpart.Length != 2))
   {
   macOkay = false;
   }
   }
   else
   {
   macOkay = false;
   }
   return macOkay;
   }

   public static bool check_mac3(string macadresse)
   {
   if (macadresse.Length != 17)
   return false;
   for (int i = 0; i < macadresse.Length; ++i) { if (i % 3 == 2) { if (macadresse[i] != ':') return false; } else if ((macadresse[i] >= ‚0‘ && macadresse[i] <= '9') || (macadresse[i] >= ‚a‘ && macadresse[i] <= 'f') || (macadresse[i] >= ‚A‘ && macadresse[i] <= 'F')) return false; } return true; } public static bool check_mac4(string macadresse) { if (Regex.IsMatch(macadresse, @"^(?:([da-f]{2}):){5}[da-f]{2}$", RegexOptions.IgnoreCase)) return true; return false; } private static Regex MacCheckRegex = new Regex(@"^(?:[0-9A-F]{2}[:-]){5}(?:[0-9A-F]{2})$", RegexOptions.IgnoreCase); public static bool check_mac5(string macadresse) { return MacCheckRegex.IsMatch(macadresse); } }[/code] Ich erhielt folgende Ergebnisse: [code]Original: 2744 als long: 7584 Meine Lsg.: 301 Regex: 17743 static Regex: 9995[/code] Meine Lösung ist als mit Abstand die schnellste. Das ist ganz einfach der Programmierung geshculdet. Ich überprüfe jedes Zeichen nur einmal und Fertig. Ein Regex muss noch initialisiert werden und auch die Abfrage kann der Leistungsaufwendig werden. Das merkt man auch bei den Messungen, Regex ist in beiden Varianten das Langsamste. Letzten Endes macht es trotzdem kaum einen Unterschied, da die Methode wohl keine 10 Millionen mal aufgerufen wird. Muss man die Methode jedoch oft aufrufen, sollte man über eine Effektivierung nachdenken. PS: Weil die Hexadezimalzahlen in den Adressen nicht immer Zweistellig sind werden auch ungültige Zeichenfolgen erzeugt. So wird auch eine gewisse Fehlerrate eingeschlossen. Auch wenn diese nicht sehr groß ist.

6. Danke für die Kommentare, ich werde es bei Gelegenheit entsprechend verbessern.