Envoi d'e-mail avec ASP.Net (Version C#)

Une fonctionnalité qui peut être très intéressante à implémenter dans une application est l'envoi d'e-mail, que cela soit automatisé ou manuel. ASP.Net permet de réaliser des choses relativement complexes sans pour autant nécessiter de grandes connaissances.

Au cours de cet article, nous allons donc voir comment envoyer des e-mails grâce à ASP.Net. Les explications seront volontairement très détaillées pour permettre même aux débutants d'envoyer des e-mails par ASP.Net.

Les exemples seront donnés en C# et le logiciel utilisé sera Visual Studio.Net, mais ces exemples pourront aussi fonctionner avec WebMatrix moyennant de très petites adaptations.

Il s'agit du namespace utilisé par .Net pour l'envoi d'e-mail dans les applications. Il contient 3 classes qui ont des rôles complémentaires :

• MailMessage : permet de créer un e-mail, en définissant ses différentes propriétés ;
• MailAttachement : permet de créer des pièces jointes aux e-mails ;
• SmtpMail : permet la communication avec le serveur SMTP et l'expédition de l'e-mail.

Ce namespace n'autorise que l'envoi d'e-mail, et ne permet pas la consultation de boîtes aux lettres, pour cela il faut faire appel à d'autres composants pour se connecter aux serveurs, le protocole utilisé n'est alors plus SMTP mais POP ou encore IMAP.

Dans cette partie nous allons voir comment envoyer un e-mail de base, c'est-à-dire sans pièce jointe et au format texte.

II-A. Création de l'interface▲

Nous allons rapidement créer une interface pour l'envoi d'e-mail, elle sera volontairement simpliste. Je l'ai réalisée avec Visual Studio mais vous pouvez bien évidemment la faire avec n'importe quel IDE. Dans ce WebForm il nous faudra les éléments suivants :

• 3 TextBox simple ligne ;
• 1 TextBox multiligne ;
• 1 bouton.

Voici une capture d'écran montrant à quoi va ressembler notre interface :

Pour plus de simplicité et si vous voulez utiliser directement le code de cet article je vous recommande de nommer les différents contrôles comme moi, de haut en bas voici les ID à attribuer :

• tbExpediteur ;
• tbDestinataire ;
• tbObjet ;
• tbMessage ;
• lblErreur ;
• btEnvoyer.

Une fois cette interface réalisée nous pouvons débuter l'écriture du code.

II-B. Écriture du code▲

using System.Web.Mail;

private void btEnvoyer_Click(object sender, System.EventArgs e)
{
}

MailMessage email = new MailMessage();

email.From = tbExpediteur.Text;
email.To = tbDestinataire.Text;
email.Subject = tbObjet.Text;
email.Body = tbMessage.Text;

SmtpMail.SmtpServer = "mon_serveur_smtp";

private void btEnvoyer_Click(object sender, System.EventArgs e)
{
 MailMessage email = new MailMessage();
 email.From = tbExpediteur.Text;
 email.To = tbDestinataire.Text;
 email.Subject = tbObjet.Text;
 email.Body = tbMessage.Text;
 email.Priority = MailPriority.High;
 SmtpMail.SmtpServer = "mon_serveur_smtp";
 try {
   SmtpMail.Send(email);
 } catch (Exception ex) {
   lblErreur.Text = ex.Message;
 }
}

Le petit défaut de la technique présentée plus haut est le fait qu'il faille utiliser son propre serveur de mail interne ou alors un serveur de mail configuré en Open Relay…

Mais heureusement une solution efficace existe, il suffit de s'authentifier auprès du serveur de mail utilisé par le biais d'un compte de messagerie ayant les droits adéquats. C'est-à-dire par exemple votre compte de messagerie que vous utilisez tous les jours pour envoyer et recevoir des e-mails. Vous allez voir que cela n'est vraiment pas compliqué, trois lignes suffisent pour implémenter une authentification dans votre code. Dans les lignes qui viennent, nous allons voir deux méthodes, une employant le fichier Web.Config pour stocker les informations relatives à votre compte SMTP, et l'autre non.

III-A. Avec utilisation du fichier Web.Config▲

<appSettings>
    <add key="SmtpServeur" value="smtp.mon_serveur.com" />
    <add key="SmtpUtilisateur" value="mon_login" />
    <add key="SmtpPassword" value="mon_password" />
</appSettings>

string utilisateur;
string password;
string serveur;

utilisateur = ConfigurationSettings.AppSettings["SmtpUtilisateur"];
password = ConfigurationSettings.AppSettings["SmtpPassword"];
serveur = ConfigurationSettings.AppSettings["SmtpServeur"];

email.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpauthenticate", "1");
email.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendusername", utilisateur);
email.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendpassword", password);
SmtpMail.SmtpServer = serveur;

MailMessage email = new MailMessage();
string utilisateur;
string password;
string serveur;

utilisateur = ConfigurationSettings.AppSettings["SmtpUtilisateur"];
password = ConfigurationSettings.AppSettings["SmtpPassword"];
serveur = ConfigurationSettings.AppSettings["SmtpServeur"];

email.From = tbExpediteur.Text;
email.To = tbDestinataire.Text;
email.Subject = tbObjet.Text;
email.Body = tbMessage.Text;
SmtpMail.SmtpServer = serveur;

email.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpauthenticate", "1");
email.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendusername", utilisateur);
email.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendpassword", password);

try {
 SmtpMail.Send(email);
} catch (Exception ex) {
 lblError.Text = ex.Message;
}

<appSettings>
   <add key="SmtpServeur" value="smtp.mon_serveur.com" />
   <add key="SmtpUtilisateur" value="mon_login" />
   <add key="SmtpPassword" value="mon_password" />
</appSettings>

III-B. Sans utilisation du fichier Web.Config▲

email.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendusername", "utilisateur");
email.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendpassword", "mot_de_passe");
SmtpMail.SmtpServer = "votre_serveur_smtp";

string utilisateur;
string password;
string serveur;
utilisateur = ConfigurationSettings.AppSettings["SmtpUtilisateur"];
password = ConfigurationSettings.AppSettings["SmtpPassword"];
serveur = ConfigurationSettings.AppSettings["SmtpServeur"];

Nous allons apprendre dans cette section comment envoyer un e-mail au format HTML. Cependant il faut quand même garder à l'esprit que tous les clients de messagerie ne gèrent pas les e-mails au format HTML. Nous allons étudier ce cas dans le cadre de la génération automatique d'un e-mail par l'application, c'est-à-dire que par exemple le texte du message ne sera pas récupéré dans une TextBox mais sera inscrit en dur dans le code. Mais il est tout à fait possible et très simple de récupérer ce texte ou d'autres éléments de manière dynamique.

Passons à la pratique. Pour envoyer des mails au format HTML il faut tout d'abord ajouter la ligne suivante dans votre code :

email.BodyFormat = MailFormat.Html;

C'est en effet extrêmement complexe ! ;)

Puis il faut bien entendu donner le code HTML de votre courrier, cela peut s'avérer un peu plus difficile si vous ne connaissez pas ce langage. Mais une fois de plus il ne faut pas s'affoler, il s'agit d'un langage très simple. Voici un exemple de code HTML de base (on ne peut quasiment pas faire plus simple !).

<html>
<head>
<meta http-equiv="Content-Language" content="fr">
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
</head>
<body>
<p>Mon premier mail au format HTML</p>
</body>
</html>

Si vous ne souhaitez pas éditer votre page HTML à la main, vous pouvez bien sûr utiliser n'importe quel logiciel permettant de créer de tels documents, mais certains ne respectent pas suffisamment les standards et il est possible que suivant votre client de messagerie le résultat varie. Cet article n'ayant pas pour objet la programmation HTML je vous renvoie à la section correspondante sur Developpez.com : ici

Au lieu de n'avoir que le texte brut dans le Body de notre e-mail nous allons aussi lui adjoindre tout le code HTML qui va créer la mise en forme. Mais il va y avoir une petite manipulation à réaliser pour que cela fonctionne. La propriété .body d'un e-mail étant une chaîne de caractères délimitée par des " il va y avoir des problèmes de syntaxe du fait que notre code HTML contient déjà des guillemets ("), la solution est de remplacer tous les guillemets dans notre code HTML par des \. Pour effectuer cela, vous n'avez qu'à utiliser votre éditeur de texte favori avec la fonction remplacer (en remplaçant les " par des \). Voilà ce que va donner notre exemple:

<html>
<head>
<meta http-equiv=\"Content-Language\" content=\"fr\">
<meta http-equiv=\"Content-Type\" content=\"text/html; charset=windows-1252\">
</head>
<body>
<p>Mon premier mail au format HTML</p>
</body>
</html>

Rien de bien méchant…

Une dernière petite difficulté est encore à surmonter. En effet notre code HTML devra se trouver sur une seule et même ligne dans le code de notre application, imaginez la longueur de la ligne si notre page est très chargée ! Heureusement une fois de plus il y a une solution, nous allons considérer chaque ligne de notre page comme une chaîne, et les concaténer. En C# pour concaténer des chaines de caractères sur plusieurs lignes il faut encadrer chaque ligne par des " et ajouter + au début de chaque ligne, sauf la première. Voilà ce que va donner notre exemple :

"<html>"
+ "<head>"
+ "<meta http-equiv=\"Content-Language\" content=\"fr\">"
+ "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=windows-1252\">"
+ "</head>"
+ "<body>"
+ "<p>Mon premier mail au format HTML</p>"
+ "</body>"
+ "</html>";

Il ne vous reste plus qu'à copier tout ça dans le code de votre application en le mettant dans la propriété .body de votre mail, voilà le résultat:

email.Body = "<html>"
+ "<head>"
+ "<meta http-equiv=\"Content-Language\" content=\"fr\">"
+ "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=windows-1252\">"
+ "</head>"
+ "<body>"
+ "<p>Mon premier mail au format HTML</p>"
+ "</body>"
+ "</html>";

Comme pour les étapes précédentes voilà le code complet, celui-ci permet d'envoyer de manière authentifiée un e-mail au format HTML :

MailMessage email = new MailMessage();
string utilisateur;
string password;
string serveur;

utilisateur = ConfigurationSettings.AppSettings["SmtpUtilisateur"];
password = ConfigurationSettings.AppSettings["SmtpPassword"];
serveur = ConfigurationSettings.AppSettings["SmtpServeur"];

email.From = tbExpediteur.Text;
email.To = tbDestinataire.Text;
email.Subject = tbObjet.Text;
email.BodyFormat = MailFormat.Html;
email.Body = "<html>"
            + "<head>"
       + "<meta http-equiv="Content-Language" content="fr">"
       + "<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">"
       + "</head>"
       + "<body>"
       + "<p>Mon premier mail au format HTML</p>"
       + "</body>"
       + "</html>";
       
SmtpMail.SmtpServer = serveur;

email.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpauthenticate", "1");
email.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendusername", utilisateur);
email.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendpassword", password);

try {
SmtpMail.Send(email);
} catch (Exception ex) {
lblErreur.Text = ex.Message;
}

Pour envoyer des e-mails comme avec n'importe quel client de messagerie il nous manque une chose, la pièce jointe, mais plus pour très longtemps…

Remarque : vous pouvez par exemple ajouter dans le corps du mail des variables contenant des valeurs récupérées dans une base de données, une utilisation de cela pourrait être la confirmation automatique par e-mail d'une inscription.

Dans cette partie nous allons voir comment adjoindre une pièce jointe à notre e-mail. Une fois de plus avec .Net cela va être un jeu d'enfant. Il suffit d'ajouter (au même endroit que les autres propriétés) le code suivant à votre application :

string chemin;
chemin = "C:\\Inetpub\\wwwroot\\developpez\\fichiers\\toto.txt";
email.Attachments.Add(new MailAttachment(chemin));

Nous pouvons voir qu'il faut définir une variable de type chaîne pour y stocker le chemin physique complet du fichier à mettre en pièce jointe, puis de passer ce chemin dans la ligne créant une instance de la pièce jointe. Mon code n'est pas très affiné, vous pouvez bien entendu récupérer le chemin de façon dynamique en utilisant par exemple le File Field HTML dans Visual Studio ou son équivalent dans WebMatrix.

On voit donc qu'il est très aisé d'envoyer des e-mails avec ASP.Net, les trois classes du namespace System.Web.Mail du .Net Framework permettent de paramétrer finement la création et l'envoi d'e-mail. On peut par exemple envoyer automatiquement des mails au format HTML, qui sont alimentés par une base de données, sans pour que cela nécessite des connaissances trop poussées. System.Web.Mail est donc très puissant et brille surtout par sa simplicité de mise en œuvre, en effet même un programmeur .Net débutant pourra s'en sortir.

Merci beaucoup à Anomaly, Ditch, Abelman, Morpheus et David Pédehourcq pour la relecture.