E-Mail-Adresse Spaltung

Question

So habe ich eine Zeichenfolge, die ich durch Semikolon der

E-Mail-Adresse teilen müssen: "one@tw;,.'o"@hotmail.com;"some;thing"@example.com

Sowohl der E-Mail-Adressen gültig sind

Deshalb möchte ich haben ein List<string> der folgenden Möglichkeiten:

• "one@tw;,.'o"@hotmail .com
• "some;thing"@example.com

Aber die Art, wie ich zur Zeit die Adressen am Aufspalten funktioniert nicht:

var addresses = emailAddressString.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries) 
       .Select(x => x.Trim()).ToList(); 

Wegen der mehrfachen ; Charaktere, die ich am Ende mit ungültige E-Mail-Adressen

Ich habe ein paar verschiedene Möglichkeiten ausprobiert, sogar hinunter arbeiten, wenn die Zeichenfolge Zitate enthält und dann den Index der ; Zeichen finden und es auf diese Weise funktioniert, aber es ist ein echter Schmerz.

Hat jemand bessere Vorschläge?

Answer 1

Ich begann offensichtlich meine Anti-Regex-Methode etwa zur gleichen Zeit wie juharr (eine andere Antwort) zu schreiben. Ich dachte, da ich es schon geschrieben habe, würde ich es einreichen.

public static IEnumerable<string> SplitEmailsByDelimiter(string input, char delimiter) 
    { 
     var startIndex = 0; 
     var delimiterIndex = 0; 

     while (delimiterIndex >= 0) 
     { 
      delimiterIndex = input.IndexOf(';', startIndex); 
      string substring = input; 
      if (delimiterIndex > 0) 
      { 
       substring = input.Substring(0, delimiterIndex); 
      } 

      if (!substring.Contains("\"") || substring.IndexOf("\"") != substring.LastIndexOf("\"")) 
      { 
       yield return substring; 
       input = input.Substring(delimiterIndex + 1); 
       startIndex = 0; 
      } 
      else 
      { 
       startIndex = delimiterIndex + 1; 
      } 
     } 
    } 

Dann wurde die folgende

  var input = "blah@blah.com;\"one@tw;,.'o\"@hotmail.com;\"some;thing\"@example.com;hello@world;asdasd@asd.co.uk;"; 
      foreach (var email in SplitEmailsByDelimiter(input, ';')) 
      { 
       Console.WriteLine(email); 
      } 

würde diese Ausgabe geben

blah@blah.com 
"one@tw;,.'o"@hotmail.com 
"some;thing"@example.com 
hello@world 
asdasd@asd.co.uk 

Answer 2

Unter der Annahme, dass doppelte Anführungszeichen sind nicht erlaubt, außer für das Öffnen und Schließen zitiert vor dem „auf“ Zeichen @, können Sie diesen regulären Ausdruck verwenden, um E-Mail-Adressen zu erfassen:

((?:[^@"]+|"[^"]*")@[^;]+)(?:;|$) 

Die Idee ist, entweder einen nicht notierten [^@"]+ oder einen "[^"]*" Teil vor @ zu erfassen und dann alles bis zum Semikolon ; oder dem Endanker $ zu erfassen.

Demo of the regex.

var input = "\"one@tw;,.'o\"@hotmail.com;\"some;thing\"@example.com;hello@world"; 
var mm = Regex.Matches(input, "((?:[^@\"]+|\"[^\"]*\")@[^;]+)(?:;|$)"); 
foreach (Match m in mm) { 
    Console.WriteLine(m.Groups[1].Value); 
} 

Dieser Code druckt

"one@tw;,.'o"@hotmail.com 
"some;thing"@example.com 
hello@world 

Demo 1.

Wenn Sie entkam doppelte Anführungszeichen in doppelte Anführungszeichen ermöglichen möchten, können Sie einen komplexeren Ausdruck verwenden:

((?:(?:[^@\"]|(?<=\\)\")+|\"([^\"]|(?<=\\)\")*\")@[^;]+)(?:;|$) 

Alles andere bleibt gleich.

Demo 2.

Answer 3

Sie können dies auch tun, ohne reguläre Ausdrücke zu verwenden. Mit der folgenden Erweiterungsmethode können Sie ein Trennzeichen und ein Zeichen zum Starten und Beenden von Escape-Sequenzen angeben. Beachten Sie, dass nicht überprüft wird, dass alle Escape-Sequenzen geschlossen sind.

public static IEnumerable<string> SpecialSplit(
    this string str, char delimiter, char beginEndEscape) 
{ 
    int beginIndex = 0; 
    int length = 0; 
    bool escaped = false; 
    foreach (char c in str) 
    { 
     if (c == beginEndEscape) 
     { 
      escaped = !escaped; 
     } 

     if (!escaped && c == delimiter) 
     { 
      yield return str.Substring(beginIndex, length); 
      beginIndex += length + 1; 
      length = 0; 
      continue; 
     } 

     length++; 
    } 

    yield return str.Substring(beginIndex, length); 
} 

Dann wurde die folgende

var input = "\"one@tw;,.'o\"@hotmail.com;\"some;thing\"@example.com;hello@world;\"D;D@blah;blah.com\""; 
foreach (var address in input.SpecialSplit(';', '"')) 
    Console.WriteLine(v); 

Während geben diesem Ausgang

"one@tw;,.'o"@hotmail.com

"etwas, das Ding" @ beispiel.com

hallo @ welt

"D; D @ blah; blah.com" ist

Hier ist die Version, die mit einem zusätzlichen Einzel Escape-Zeichen funktioniert. Es wird davon ausgegangen, dass zwei aufeinanderfolgende Escape-Zeichen zu einem einzigen Escape-Zeichen werden sollten und es sowohl der beginEndEscape Charta entgeht, so dass es den Anfang oder das Ende einer Escape-Sequenz nicht auslöst, und es auch die delimiter entkommt. Alles andere, was nach dem Escape-Zeichen folgt, wird beibehalten, wenn das Escape-Zeichen entfernt wird.

public static IEnumerable<string> SpecialSplit(
    this string str, char delimiter, char beginEndEscape, char singleEscape) 
{ 
    StringBuilder builder = new StringBuilder(); 
    bool escapedSequence = false; 
    bool previousEscapeChar = false; 
    foreach (char c in str) 
    { 
     if (c == singleEscape && !previousEscapeChar) 
     { 
      previousEscapeChar = true; 
      continue; 
     } 

     if (c == beginEndEscape && !previousEscapeChar) 
     { 
      escapedSequence = !escapedSequence; 
     } 

     if (!escapedSequence && !previousEscapeChar && c == delimiter) 
     { 
      yield return builder.ToString(); 
      builder.Clear(); 
      continue; 
     } 

     builder.Append(c); 
     previousEscapeChar = false; 
    } 

    yield return builder.ToString(); 
} 

Schließlich sollten Sie wahrscheinlich null für die Zeichenfolge Überprüfung hinzufügen, die in und beachten Sie übergeben wird, dass sowohl eine Sequenz mit einem leeren String zurück, wenn Sie in einem leeren String.