Esiste un modo migliore per generare messaggi di posta elettronica HTML in C # (per l'invio tramite System.Net.Mail), rispetto all'utilizzo di un Stringbuilder per eseguire le seguenti operazioni:

string userName = "John Doe";
StringBuilder mailBody = new StringBuilder();
mailBody.AppendFormat("<h1>Heading Here</h1>");
mailBody.AppendFormat("Dear {0}," userName);
mailBody.AppendFormat("<br />");
mailBody.AppendFormat("<p>First part of the email body goes here</p>");

E così via e così via?

Puoi usare il file classe MailDefinition .

Ecco come lo usi:

MailDefinition md = new MailDefinition();
md.From = "test@domain.com";
md.IsBodyHtml = true;
md.Subject = "Test of MailDefinition";

ListDictionary replacements = new ListDictionary();
replacements.Add("{name}", "Martin");
replacements.Add("{country}", "Denmark");

string body = "<div>Hello {name} You're from {country}.</div>";

MailMessage msg = md.CreateMailMessage("you@anywhere.com", replacements, body, new System.Web.UI.Control());

Inoltre, ho scritto un post sul blog su come generare il corpo del messaggio di posta elettronica HTML in C # utilizzando i modelli utilizzando la classe MailDefinition .

Utilizza la classe System.Web.UI.HtmlTextWriter.

StringWriter writer = new StringWriter();
HtmlTextWriter html = new HtmlTextWriter(writer);

html.RenderBeginTag(HtmlTextWriterTag.H1);
html.WriteEncodedText("Heading Here");
html.RenderEndTag();
html.WriteEncodedText(String.Format("Dear {0}", userName));
html.WriteBreak();
html.RenderBeginTag(HtmlTextWriterTag.P);
html.WriteEncodedText("First part of the email body goes here");
html.RenderEndTag();
html.Flush();

string htmlString = writer.ToString();

Per HTML estensivo che include la creazione di attributi di stile, HtmlTextWriter è probabilmente il modo migliore per procedere. Tuttavia può essere un po 'goffo da usare e ad alcuni sviluppatori piace il markup stesso per essere letto facilmente, ma le scelte perversamente di HtmlTextWriter riguardo all'indentazione sono un po' strane.

In questo esempio puoi anche usare XmlTextWriter in modo abbastanza efficace: -

writer = new StringWriter();
XmlTextWriter xml = new XmlTextWriter(writer);
xml.Formatting = Formatting.Indented;
xml.WriteElementString("h1", "Heading Here");
xml.WriteString(String.Format("Dear {0}", userName));
xml.WriteStartElement("br");
xml.WriteEndElement();
xml.WriteElementString("p", "First part of the email body goes here");
xml.Flush();

Risposta aggiornata :

La documentazione per SmtpClient, la classe utilizzata in questa risposta, ora legge, "Obsolete (" SmtpClient e la sua rete di tipi sono mal progettati, ti consigliamo vivamente di utilizzare https://github.com/jstedfast/MailKit e https: // github .com / jstedfast / MimeKit invece ") '.

Fonte: https://www.infoq.com/news/2017/04/MailKit-MimeKit-Official

Risposta originale :

L'utilizzo della classe MailDefinition è l'approccio sbagliato. Sì, è utile, ma è anche primitivo e dipende dai controlli dell'interfaccia utente Web: non ha senso per qualcosa che è in genere un'attività lato server.

L'approccio presentato di seguito si basa sulla documentazione MSDN e sul post di Qureshi su CodeProject.com .

NOTA: questo esempio estrae il file HTML, le immagini e gli allegati dalle risorse incorporate, ma l'uso di altre alternative per ottenere flussi per questi elementi va bene, ad esempio stringhe hard-coded, file locali e così via.

Stream htmlStream = null;
Stream imageStream = null;
Stream fileStream = null;
try
{
    // Create the message.
    var from = new MailAddress(FROM_EMAIL, FROM_NAME);
    var to = new MailAddress(TO_EMAIL, TO_NAME);
    var msg = new MailMessage(from, to);
    msg.Subject = SUBJECT;
    msg.SubjectEncoding = Encoding.UTF8;
 
    // Get the HTML from an embedded resource.
    var assembly = Assembly.GetExecutingAssembly();
    htmlStream = assembly.GetManifestResourceStream(HTML_RESOURCE_PATH);
 
    // Perform replacements on the HTML file (if you're using it as a template).
    var reader = new StreamReader(htmlStream);
    var body = reader
        .ReadToEnd()
        .Replace("%TEMPLATE_TOKEN1%", TOKEN1_VALUE)
        .Replace("%TEMPLATE_TOKEN2%", TOKEN2_VALUE); // and so on...
 
    // Create an alternate view and add it to the email.
    var altView = AlternateView.CreateAlternateViewFromString(body, null, MediaTypeNames.Text.Html);
    msg.AlternateViews.Add(altView);
 
    // Get the image from an embedded resource. The <img> tag in the HTML is:
    //     <img src="pid:IMAGE.PNG">
    imageStream = assembly.GetManifestResourceStream(IMAGE_RESOURCE_PATH);
    var linkedImage = new LinkedResource(imageStream, "image/png");
    linkedImage.ContentId = "IMAGE.PNG";
    altView.LinkedResources.Add(linkedImage);
 
    // Get the attachment from an embedded resource.
    fileStream = assembly.GetManifestResourceStream(FILE_RESOURCE_PATH);
    var file = new Attachment(fileStream, MediaTypeNames.Application.Pdf);
    file.Name = "FILE.PDF";
    msg.Attachments.Add(file);
 
    // Send the email
    var client = new SmtpClient(...);
    client.Credentials = new NetworkCredential(...);
    client.Send(msg);
}
finally
{
    if (fileStream != null) fileStream.Dispose();
    if (imageStream != null) imageStream.Dispose();
    if (htmlStream != null) htmlStream.Dispose();
}

Uso dotLiquid esattamente per questo compito.

Prende un modello e riempie identificatori speciali con il contenuto di un oggetto anonimo.

//define template
String templateSource = "<h1>{{Heading}}</h1>Dear {{UserName}},<br/><p>First part of the email body goes here");
Template bodyTemplate = Template.Parse(templateSource); // Parses and compiles the template source

//Create DTO for the renderer
var bodyDto = new {
    Heading = "Heading Here",
    UserName = userName
};
String bodyText = bodyTemplate.Render(Hash.FromAnonymousObject(bodyDto));

Funziona anche con le raccolte, guarda alcuni esempi online .

Consiglierei di utilizzare modelli di qualche tipo. Ci sono vari modi diversi per affrontare questo problema, ma essenzialmente tieni un modello dell'E-mail da qualche parte (su disco, in un database, ecc.) E inserisci semplicemente i dati chiave (IE: nome dei destinatari ecc.) Nel modello.

Questo è molto più flessibile perché significa che puoi modificare il modello come richiesto senza dover modificare il tuo codice. Nella mia esperienza è probabile che tu riceva richieste di modifica ai modelli da parte degli utenti finali. Se vuoi andare fino in fondo potresti includere un editor di modelli.

In alternativa a MailDefinition, dai un'occhiata a RazorEngine https://github.com/Antaris/RazorEngine .

Questa sembra una soluzione migliore.

Attribuito a ...

come inviare e-mail con il modello di e-mail c #

Per esempio

using RazorEngine;
using RazorEngine.Templating;
using System;

namespace RazorEngineTest
{
    class Program
    {
        static void Main(string[] args)
        {
    string template =
    @"<h1>Heading Here</h1>
Dear @Model.UserName,
<br />
<p>First part of the email body goes here</p>";

    const string templateKey = "tpl";

    // Better to compile once
    Engine.Razor.AddTemplate(templateKey, template);
    Engine.Razor.Compile(templateKey);

    // Run is quicker than compile and run
    string output = Engine.Razor.Run(
        templateKey, 
        model: new
        {
            UserName = "Fred"
        });

    Console.WriteLine(output);
        }
    }
}

Quali uscite ...

<h1>Heading Here</h1>
Dear Fred,
<br />
<p>First part of the email body goes here</p>

Dirigendosi qui

Caro Fred,

La prima parte del corpo dell'email va qui

Emettere html costruito a mano in questo modo è probabilmente il modo migliore fintanto che il markup non è troppo complicato. Il costruttore di stringhe inizia a ripagarti in termini di efficienza solo dopo circa tre concatenazioni, quindi per cose davvero semplici stringa + stringa andrà bene.

Oltre a questo puoi iniziare a utilizzare i controlli html (System.Web.UI.HtmlControls) e renderli, in questo modo a volte puoi ereditarli e creare la tua classificazione per layout condizionale complesso.

Potresti voler dare un'occhiata ad alcuni dei framework di modelli che sono disponibili al momento. Alcuni di loro sono spin off come risultato di MVC ma non è necessario. Spark è buono.

Se non vuoi una dipendenza dal .NET Framework completo, c'è anche una libreria che fa sembrare il tuo codice:

string userName = "John Doe";

var mailBody = new HTML {
    new H(1) {
        "Heading Here"
    },
    new P {
        string.Format("Dear {0},", userName),
        new Br()
    },
    new P {
        "First part of the email body goes here"
    }
};

string htmlString = mailBody.Render();

È open source, puoi scaricarlo da http://sourceforge.net/projects/htmlplusplus/

Dichiarazione di non responsabilità: sono l'autore di questa libreria, è stata scritta per risolvere esattamente lo stesso problema: inviare un'e-mail HTML da un'applicazione.

Una versione commerciale che utilizzo in produzione e che consente una facile manutenzione è LimiLabs Template Engine , lo uso da più di 3 anni e mi permette di apportare modifiche al modello di testo senza dover aggiornare il codice (disclaimer, link, ecc.) - it potrebbe essere semplice come

Contact templateData = ...; 
string html = Template
     .FromFile("template.txt")
     .DataFrom(templateData )
     .Render();

Vale la pena dare un'occhiata, come ho fatto io; dopo aver tentato varie risposte qui menzionate.