Send Email Messages and Attachments Using C#

The class begins with the default and added imports; note the addition of System.Net.Mail, System.Net.Mime, and System.Text.RegularExpressions.

using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Linq;
using System.Net.Mail;
using System.Net.Mime;
using System.Text.RegularExpressions;
using System.Web;

The next section contains the namespace and class declarations.

namespace EmailHandler
{
    public class Emailer
    {

The first method contained in this class is used to send an email message without an attachment. The method collects the recipient email address, the sender's email address, the email subject line, and the message body as arguments. Within the code, the recipient's email address is validated, a new mail message is constructed using the passed in arguments, an instance of an SMTP client is created using the mail server (stored in the properties), a Boolean is set to enable the requests to include the default credentials, and then the message is sent. If the action succeeds, the method will return a string indicating that the submittal was successful, else, the exception message will be returned to the caller.

/// <summary>
/// Transmit an email message to a recipient without
/// any attachments
/// </summary>
/// <param name="sendTo">Recipient Email Address</param>
/// <param name="sendFrom">Sender Email Address</param>
/// <param name="sendSubject">Subject Line Describing Message</param>
/// <param name="sendMessage">The Email Message Body</param>
/// <returns>Status Message as String</returns>
public static string SendMessage(string sendTo, string sendFrom,
    string sendSubject, string sendMessage)
{
    try
    {
        // validate the email address
        bool bTest = ValidateEmailAddress(sendTo);
        // if the email address is bad, return message
        if (bTest == false)
            return "Invalid recipient email address: " + sendTo;
        // create the email message
        MailMessage message = new MailMessage(
           sendFrom,
           sendTo,
           sendSubject,
           sendMessage);
        // create smtp client at mail server location
        SmtpClient client = new
        SmtpClient(Properties.Settings.Default.SMTPAddress);
        // add credentials
        client.UseDefaultCredentials = true;
        // send message
        client.Send(message);
        return "Message sent to " + sendTo + " at " +
        DateTime.Now.ToString() + ".";
    }
    catch (Exception ex)
    {
        return ex.Message.ToString();
    }
}

That next method contained in the class is used to send an email message with an attachment. This method is the same as the previous with the exception being that it also accepts an array list containing the paths to files to be included as attachments to the message. The code is annotated and should be easy enough to follow.

/// <summary>
/// Transmit an email message with
/// attachments
/// </summary>
/// <param name="sendTo">Recipient Email Address</param>
/// <param name="sendFrom">Sender Email Address</param>
/// <param name="sendSubject">Subject Line Describing Message</param>
/// <param name="sendMessage">The Email Message Body</param>
/// <param name="attachments">A string array pointing to the location  
    of each attachment</param>
/// <returns>Status Message as String</returns>
public static string SendMessageWithAttachment(string sendTo, string
sendFrom, string sendSubject, string sendMessage, ArrayList
attachments)
{
    try
    {
        // validate email address
        bool bTest = ValidateEmailAddress(sendTo);
        if (bTest == false)
            return "Invalid recipient email address: " + sendTo;
        // Create the basic message
        MailMessage message = new MailMessage(
           sendFrom,
           sendTo,
           sendSubject,
           sendMessage);
        // The attachments array should point to a file location     
        // where
        // the attachment resides - add the attachments to the
        // message
        foreach (string attach in attachments)
        {
            Attachment attached = new Attachment(attach,
            MediaTypeNames.Application.Octet);
            message.Attachments.Add(attached);
        }
        // create smtp client at mail server location
        SmtpClient client = new
        SmtpClient(Properties.Settings.Default.SMTPAddress);
        // Add credentials
        client.UseDefaultCredentials = true;
        // send message
        client.Send(message);
        return "Message sent to " + sendTo + " at " +
        DateTime.Now.ToString() + ".";
    }
    catch (Exception ex)
    {
        return ex.Message.ToString();
    }
}

The last method contained in the Emailer class is used to validate an email address; this is accomplished by validating the address against a regular expression.

/// <summary>
/// Confirm that an email address is valid
/// in format
/// </summary>
/// <param name="emailAddress">Full email address to validate</param>
/// <returns>True if email address is valid</returns>
public static bool ValidateEmailAddress(string emailAddress)
{
    try
    {
        string TextToValidate = emailAddress;
        Regex expression = new Regex(@"\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}");
        // test email address with expression
        if (expression.IsMatch(TextToValidate))
        {
            // is valid email address
            return true;
        }
        else
        {
            // is not valid email address
            return false;
        }
    }
    catch (Exception)
    {
        throw;
    }
}

Code: frmTestEmailer.cs

This form class is the only class contained in the test application; it provides a simple interface for building an email message with attachments.

The class begins with the default imports.

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using EmailHandler;

The next section contains the namespace and class declarations.

namespace EmailTestApp
{
    /// <summary>
    /// Test Application Form:
    /// This application is used to test sending
    /// email and email with attachments.
    /// </summary>
    public partial class frmTestEmail : Form
    {

Following the class declaration, an ArrayList is declared; this is used to contain the attachments added to the email message.

/// <summary>
/// An arraylist containing
/// all of the attachments
/// </summary>
ArrayList alAttachments;

The next bit of code in the application is the default constructor.

/// <summary>
/// Default constructor
/// </summary>
public frmTestEmail()
{
    InitializeComponent();
}

The next bit of code is the button click event handler used to add attachments to the email message. The code adds the file or files selected from an open file dialog to the array list used to store the file paths temporarily; the contents of the array list as written out and displayed in a text box contained on the form.

/// <summary>
/// Add files to be attached to the email message
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnAdd_Click(object sender, EventArgs e)
{
    if (openFileDialog1.ShowDialog() == DialogResult.OK)
    {
        try
        {
            string[] arr = openFileDialog1.FileNames;
            alAttachments = new ArrayList();
            txtAttachments.Text = string.Empty;
            alAttachments.AddRange(arr);
            foreach (string s in alAttachments)
            {
                txtAttachments.Text += s + "; ";
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message, "Error");
        }
    }
}

That next method contained in the class is used to exit the application. It is the button click event handler for the cancel button.

/// <summary>
/// Exit the application
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnCancel_Click(object sender, EventArgs e)
{
    Application.Exit();
}

The last method contained in the test application form is used to send the email message. This is the button click event handler for the send button. This method verifies that all of the required elements of the message are available and then uses those form fields to supply each of the arguments used in the SendMessage or SendMessageWithAttachments methods contained in the Emailer class. Based upon whether or not the message contains any attachments, the appropriate method is called.

/// <summary>
/// Send an email message with or without attachments
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnSend_Click(object sender, EventArgs e)
{
    if (String.IsNullOrEmpty(txtSendTo.Text))
    {
        MessageBox.Show("Missing recipient address.", "Email Error");
        return;
    }
    if (String.IsNullOrEmpty(txtSendFrom.Text))
    {
        MessageBox.Show("Missing sender address.", "Email Error");
        return;
    }
    if (String.IsNullOrEmpty(txtSubjectLine.Text))
    {
        MessageBox.Show("Missing subject line.", "Email Error");
        return;
    }
    if (String.IsNullOrEmpty(txtMessage.Text))
    {
        MessageBox.Show("Missing message.", "Email Error");
        return;
    }
    string[] arr = txtAttachments.Text.Split(';');
    alAttachments = new ArrayList();
    for (int i = 0; i < arr.Length; i++)
    {
        if (!String.IsNullOrEmpty(arr[i].ToString().Trim()))
        {
            alAttachments.Add(arr[i].ToString().Trim());
        }
    }
    // if there are attachments, send message with
    // SendMessageWithAttachment call, else use the
    // standard SendMessage call
    if (alAttachments.Count > 0)
    {
        string result =
        Emailer.SendMessageWithAttachment(txtSendTo.Text,
            txtSendFrom.Text, txtSubjectLine.Text, txtMessage.Text,
            alAttachments);
        MessageBox.Show(result, "Email Transmittal");
    }
    else
    {
        string result = Emailer.SendMessage(txtSendTo.Text,
            txtSendFrom.Text, txtSubjectLine.Text, txtMessage.Text);
        MessageBox.Show(result, "Email Transmittal");
    }
}

Summary

The article provides a simple description of the process required to send an email message with our without attachments. Further, the procedure for configuring IIS and the STMP mail server is described.