EmailVerify for .NET
Advanced email validation component for Microsoft .NET
- Advanced syntax verification, according to IETF standards (RFC 1123, RFC 2821, RFC 2822, RFC 3490, RFC 3696, RFC 4291, RFC 5321, RFC 5322 and RFC 5336), with support for quoted words, domain literals, non-ASCII domain names (IDNA) and mailboxes, and comments
- ISP-specific syntax check (Gmail, Yahoo, Hotmail, Aol, Rediff and many others supported)
- DNS validations, including MX record(s) lookup
- Disposable and temporary email address detection
- SMTP connection and availability checking
- Mailbox existence checking, with greylisting and temporary unavailability support
- Catch-all testing
It is completely written in managed code (C#) and is compliant with Common Language Specification (CLS), so it can be used with any other .NET language too, including Visual Basic (VB.NET), C++/CLI, J#, IronPython, IronRuby, F# and PowerShell.
Why choose
Easy to Use
Designed from the ground up to make the developer's life easier, EmailVerify for .NET's whole architecture let you perform a full email validation with just a single method call, whether the job is as simple as a syntax check or as complex as a mailbox existence test.
Here is, for example, what it takes to validate an email address using the default settings for the component:
var engine = new VerificationEngine();
var result = engine.Run("john@example.com",
VerificationLevel.Mailbox).Result;
if (result.LastStatus == VerificationStatus.Success)
{
// TODO: Show a message box with the great news
}
Powerful and Completely Configurable
With a very stable and mature code base, EmailVerify for .NET supports eight different e-mail address verification levels and allows you to configure every possible aspect of the validation process, including adherence to IETF standards preferences, network-related settings, timeouts for multi-threaded activities and even your own custom validation rules, embedded into the main email verification pipeline.
In the following snippet, for example, EmailVerify for .NET is configured not to allow domain literals in e-mail addresses, while allowing comments and quoted strings. Furthermore, the component is set to use a particular DNS server (instead of a system-configured server) for its lookups:
var settings = new VerificationSettings
{
AllowDomainLiterals = false,
AllowComments = true,
AllowQuotedStrings = true
};
// The component will use just the provided DNS server for its lookups
settings.DnsServers.Clear();
settings.DnsServers.Add(IPAddress.Parse("8.8.8.8"));
// Pass the configured settings to the verification engine
var result = engine.Run("john@example.com",
VerificationLevel.Mailbox,
settings).Result;
// ...
engine.VerificationLevelStarted += (sender, args) =>
{
Console.WriteLine("The address {0} reached level {1}",
args.Verification.InputData,
args.Level);
};
High Performance
EmailVerify for .NET internally employs a very fast, multi-threaded e-mail address validation engine capable of processing hundreds of items at once using asynchronous-based processing logic and different optimization algorithms. Furthermore, the component exposes dedicated methods and structures to track down and configure each verification activity that may take place in every asynchronous scenario at optimal performance.
var group = new VerificationGroup();
// Add some entries to the verification group
group += new Verification("alice@example.com");
group += new Verification("bob@example.net");
// One entry also has non-default settings
group += new Verification("charlie@example.org", new VerificationSettings
{
AllowInternationalDomainNames = false
});
// Start the validation of the whole group, asynchronously
await engine.RunAsync(group, VerificationLevel.Smtp);
// At this point, every address has been validated...
Does it send out any e-mail?
No, it doesn't. EmailVerify for .NET employs DNS and SMTP protocol functionalities to perform e-mail address validations and absolutely avoids sending any email message to external mail exchangers for delivery.
How does it work?
EmailVerify for .NET verifies email addresses with up to six different kinds of tools. It validates any address you give it against IETF standards (RFC 1123, RFC 2821, RFC 2822, RFC 3490, RFC 3696, RFC 4291, RFC 5321, RFC 5322 and RFC 5336, among others), thus guaranteeing its syntactical validity. Based on the target ISP, it also verifies each address against a set of intelligent rules, which exclude most typos with major email service providers.
Then it extracts the domain from each address and performs different DNS lookups to ensure that the related domain exists and is configured to accept email messages. After that, it checks an embedded database to find if that domain is a disposable email address (DEA) provider and reacts accordingly.
Next, it tries to contact the mail exchanger responsible for the given email address and begins a fake SMTP dialog with that server, emulating a real mail server. This way it ensures that the server can handle emails for the address. Many SMTP servers actually give back false positive answers as a protection against spammers: to overcome this issue, EmailVerify for .NET finally attempts to query the target mail exchanger multiple times with different fabricated addresses.
EmailVerify for .NET is completely customizable: every setting can be easily changed and tweaked to match your business requirements, and the entire email validation pipeline can be extended and mixed with your own custom logic.
Is it possible to verify more than one e-mail address at a time?
Sure! EmailVerify for .NET's unique multithreaded engine lets you perform thousands of validations at once. It features a smart algorithm that, once given a group of e-mail addresses to verify, chooses the order to process each item of the batch to maximize its overall performance, thus achieving the highest allowed degree of parallelism.
Can EmailVerify for .NET run within an ASP.NET web site?
Yes, as long as it is running with Microsoft .NET framework version 2.0 or newer (including v4.5).
Does it support Windows Forms and Windows Presentation Foundation (WPF)?
Of course! EmailVerify for .NET follows Microsoft's event-based pattern and allows for optimal integration with any desktop-based solution. The component exposes different asynchronous methods and notification events built from the ground up to support complex multi-threaded scenarios like the ones usually found in this kind of applications.