C#でメールアドレスを検証する方法

using System.Net.Mail;

public static bool IsValidSyntax(string email)
{
    return !string.IsNullOrWhiteSpace(email)
        && email.Length <= 320
        && MailAddress.TryCreate(email, out var parsed)
        && parsed.Address == email;
}

IsValidSyntax("jane@example.com");           // true
IsValidSyntax("not-an-email");               // false
IsValidSyntax("Jane <jane@example.com>");    // false

try { _ = new MailAddress(email); /* syntax ok */ }
catch (FormatException) { /* reject */ }

using System.Linq;
using DnsClient; // dotnet add package DnsClient

// LookupClient is thread-safe and caches responses — create one and reuse it.
private static readonly LookupClient Dns = new();

public static async Task<bool> HasMailRouteAsync(string domain)
{
    try
    {
        var response = await Dns.QueryAsync(domain, QueryType.MX);
        return response.Answers.MxRecords().Any();
    }
    catch (DnsResponseException)
    {
        // No reachable resolver, SERVFAIL, and similar — treat as "check later".
        return false;
    }
}

await HasMailRouteAsync("gmail.com");               // true
await HasMailRouteAsync("company-that-folded.com"); // false

var domain = email[(email.LastIndexOf('@') + 1)..];

using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text.Json.Serialization;
using System.Threading.Channels;

public record VerifyResponse(
    [property: JsonPropertyName("job_id")] string JobId,
    [property: JsonPropertyName("result")] VerifyResult Result);

public record VerifyResult(
    [property: JsonPropertyName("status")] string Status,
    [property: JsonPropertyName("score")] int Score,
    [property: JsonPropertyName("reason")] string? Reason,
    [property: JsonPropertyName("sub_flags")] IReadOnlyDictionary<string, bool> SubFlags,
    [property: JsonPropertyName("smtp")] string? Smtp = null); // pending | cached | skipped

// One HttpClient for the whole app — don't new one up per request.
private static readonly HttpClient Http = new()
{
    BaseAddress = new Uri("https://app.qualisend.com/api/v1/"),
    Timeout = TimeSpan.FromSeconds(5), // fail fast: the default is 100 s
};

// Fail open: when the API can't answer, let the address through and re-check it later.
private static readonly VerifyResult FailOpen =
    new("unknown", 0, null, new Dictionary<string, bool>());

// (email, job id) pairs whose mailbox probe is still running. A background
// worker drains this channel; use a durable queue in production.
private static readonly Channel<(string Email, string JobId)> PendingProbes =
    Channel.CreateUnbounded<(string Email, string JobId)>();

public static async Task<VerifyResult> VerifyAsync(string email)
{
    using var request = new HttpRequestMessage(HttpMethod.Post, "verify")
    {
        Content = JsonContent.Create(new { email }),
    };
    request.Headers.Authorization = new AuthenticationHeaderValue(
        "Bearer", Environment.GetEnvironmentVariable("QUALISEND_API_KEY"));

    try
    {
        using var response = await Http.SendAsync(request);
        var code = (int)response.StatusCode;
        if (code == 402 || code == 429 || code >= 500)
            return FailOpen; // out of credits, rate limited, or a server error
        response.EnsureSuccessStatusCode(); // 400/401/403: fix the request or the key

        var body = await response.Content.ReadFromJsonAsync<VerifyResponse>();
        if (body!.Result.Smtp == "pending")
            PendingProbes.Writer.TryWrite((email, body.JobId)); // finished off the request path
        return body.Result; // status: deliverable | risky | undeliverable | unknown
    }
    catch (TaskCanceledException)
    {
        return FailOpen; // timed out
    }
}

{
  "job_id": "3f9a6c1e-5b7d-4e2a-9c8f-1d2e3a4b5c6d",
  "result": {
    "status": "unknown",
    "score": 61,
    "reason": null,
    "smtp": "pending",
    "sub_flags": { "role": false, "disposable": false, "free_mail": false, "catch_all": false }
  }
}

public record JobResponse(
    [property: JsonPropertyName("status")] string Status,
    [property: JsonPropertyName("results")] IReadOnlyList<VerifyResult>? Results);

// Runs in the background worker, never in the web request. Returns null while
// the probe is still running: call it again in a few seconds.
public static async Task<VerifyResult?> GetFinalVerdictAsync(string jobId)
{
    using var request = new HttpRequestMessage(HttpMethod.Get, $"jobs/{jobId}?include=results");
    request.Headers.Authorization = new AuthenticationHeaderValue(
        "Bearer", Environment.GetEnvironmentVariable("QUALISEND_API_KEY"));

    using var response = await Http.SendAsync(request);
    response.EnsureSuccessStatusCode();

    var job = await response.Content.ReadFromJsonAsync<JobResponse>();
    return job!.Status switch
    {
        "completed" => job.Results?.FirstOrDefault(), // the final, post-SMTP verdict
        "queued" or "processing" => null,             // not finished yet
        _ => throw new InvalidOperationException($"Job {jobId} {job.Status}"), // canceled | failed
    };
}

public static async Task<VerifyResult> ValidateEmailAsync(string email)
{
    if (!IsValidSyntax(email))
        return new VerifyResult("undeliverable", 0, "invalid_email",
            new Dictionary<string, bool>());

    var domain = email[(email.LastIndexOf('@') + 1)..];
    if (!await HasMailRouteAsync(domain))
        return new VerifyResult("undeliverable", 0, "invalid_domain",
            new Dictionary<string, bool>());

    return await VerifyAsync(email); // deliverable | risky | undeliverable | unknown
}