Parsing an email string

Question

My program needs to parse an e-mail string. There are two possibilities to enter an e-mail-address. Either with the alias or without one, plain the e-mail-address.

1st possibity:

string addressWithAlias = "test my address <[email protected]>";

2nd possibility:

string addressWithoutAlias = "[email protected]";

So, I wrote two functions:

private static string[] getAddressPartsRegex(string address)
{
 string plainaddress = address.Trim();
 Regex reg = new Regex(@"(.+?(?=<))<(.*@.*?)>");
 var gr = reg.Match(plainaddress).Groups;
 return gr.Count == 1 
 ? new[] { plainaddress } 
 : new[] { gr[1].Value.Trim(), gr[2].Value.Trim() };
}
private static string[] getAddressParts(string address)
{
 var splittedAdress = address.Split(' ');
 return splittedAdress.Last().Trim().StartsWith("<") 
 ? new[] { string.Join(" ", splittedAdress.Take(splittedAdress.Length - 1)), splittedAdress.Last().Trim(' ', '<', '>') }
 : splittedAdress;
}

They both work fine and the results are the same. One uses regex, the other uses Split and Join. What would you suggest to use, and why? What is the more beautiful function? Are there any bugs I didn't see?

• Matthias Burger: @BCdotWEB the is the standard when writing an e-mail but you won't see the e-mail address, you see a name. Something like James Bond <[email protected]> will display in outlook just James Bond instead of his e-mail-address. So, this is kind of a standard :)
• paparazzo: Maybe place Regex reg = outside the method so it is only create once at run time.
• Dan Oberlam: I mean... There are way more ways to send email addresses than you listed. here, here, here for examples
• Dan Oberlam: Ultimately, the only valid email address is one that you can send email to; it is a lot more useful to see if your sending tool of choice can handle the email address than the arbitrary (hopefully subset, but notalways) criteria from the RFC you chose to enforce. Even then, you can't validate that it is a real email address - the only way to do that is by sending it.
• MCMastery: ex-parrot.com/~pdw/Mail-RFC822-Address.html

Answer 1

Consider taking advantage of existing features that could provide an additional layer of validation.

mainly System.Net.Mail.MailAddress

Also as mentioned in a comment, no need to be creating the regular expression every time the function is called.

static Regex mailExpression = new Regex(@"(.+?(?=<))<(.*@.*?)>");
private static MailAddress getAddress(string address) {
 if (address == null) throw new ArgumentNullException("address");
 if (string.IsNullOrWhiteSpace(address)) throw new ArgumentException("invalid address", "address");
 var plainaddress = address.Trim();
 var groups = mailExpression.Match(plainaddress).Groups;
 return groups.Count == 1
 ? new MailAddress(plainaddress)
 : new MailAddress(groups[2].Value.Trim(), groups[1].Value.Trim());
}

According to reference source code, internally MailAddress will try to parse the address given to it.

This avoids having to roll your own parser as one already exists out of the box that has been tried, tested and is stable.

private static MailAddress getAddress(string address) {
 if (address == null) throw new ArgumentNullException("address");
 if (string.IsNullOrWhiteSpace(address)) throw new ArgumentException("invalid address", "address");
 address = address.Trim();
 return new MailAddress(address);
}

You have the added advantage of having a strongly typed object model to work with that will provide you with usable properties.

The following Unit Test demonstrates the desired behavior.

[TestClass]
public class EmailParserTest {
 [TestMethod]
 public void Should_Parse_EmailAddress_With_Alias() {
 //Arrange
 var expectedAlias = "test my address";
 var expectedAddress = "[email protected]";
 string addressWithAlias = "test my address <[email protected]>";
 //Act
 var mailAddressWithAlias = getAddress(addressWithAlias);
 //Assert
 mailAddressWithAlias
 .Should()
 .NotBeNull()
 .And.Match<MailAddress>(_ => _.Address == expectedAddress && _.DisplayName == expectedAlias);
 }
 [TestMethod]
 public void Should_Parse_EmailAddress_Without_Alias() {
 //Arrange
 var addressWithoutAlias = "[email protected]";
 //Act
 var mailAddressWithoutAlias = getAddress(addressWithoutAlias);
 //Assert
 mailAddressWithoutAlias
 .Should()
 .NotBeNull()
 .And.Match<MailAddress>(_ => _.Address == addressWithoutAlias && _.DisplayName == string.Empty);
 ;
 }
 private static MailAddress getAddress(string address) {
 if (address == null) throw new ArgumentNullException("address");
 if (string.IsNullOrWhiteSpace(address)) throw new ArgumentException("invalid address", "address");
 address = address.Trim();
 return new MailAddress(address);
 }
}

• Matthias Burger: I'm working with MimeKit.MailboxAddress here, poorly, the Mimekit-library doesn't do me that favour, Mailkit throws error. But you are right, of course :)
• Matthias Burger: i now let system.net.mail do this thing. it's better indeed. and interesting unit-test. what lib you use?
• Nkosi: I used the standard VS testing tools for the test runner and Fluent Assertions to assert
• Jesse C. Slicer: If you're wanting the regex, go one farther and declare it static readonly Regex mailExpression = new Regex(@"(.+?(?=<))<(.*@.*?)>", RegexOptions.Compiled);

Answer 2

Let me suggest an alternative regular expression, that correctly handles both cases:

(.*?)<?(\b\S+@\S+\b)>?

This regular expression correctly identifies both patterns you want to support. Somewhat noteworthy here is the use of \S in the email-address to exclude whitespace characters, which are incorrectly allowed in your orignal regex. That led to accepting something like the following as valid Email specification:

bla bla <te st@ exampl e.com>

Another thing that this regex does is accept Specifications of email adresses that do not require the email to be enclosed in <>. This happens by ensuring the address is surrounded by word boundaries (\b).

You should be able to easily use it like so:

static Regex mailExpression = new Regex(@"(.*?)<?(\b\S+@\S+\b)>?");
private static String[] getAddressParts(string addressSpec) 
{
 var groups = mailExpression.Match(addressSpec).Groups;
 return groups[1] == "" 
 ? new[] { groups[2].Value }
 : new[] { groups[1].Value.Trim(), groups[2].Value };
}

This does of course not preclude using the very valid suggestion by Nkosi

• Vogel612: FWIW this regex does not correctly deal with quoted-string local parts... A fix is pretty simple, though and left as an exercise in regex for the reader.

Answer 3

If you are using MimeKit, then you can use the methods Parse and TryParse of MailboxAddress. Here's a modified version of the above unit test.

[TestMethod]
public void Should_Parse_EmailAddress_With_Alias()
{
 //Arrange
 var expectedAlias = "test my address";
 var expectedAddress = "[email protected]";
 string addressWithAlias = "test my address <[email protected]>";
 //Act
 var mailAddressWithAlias = MimeKit.MailboxAddress.Parse(addressWithAlias);
 //Assert
 Assert.AreEqual(expectedAddress, mailAddressWithAlias.Address);
 Assert.AreEqual(expectedAlias, mailAddressWithAlias.Name);
}