Ce qui est une bonne façon de faire de la chaîne de création de modèles dans .NET?

Utiliser un moteur de template. StringTemplate est l'un de ceux, et ils sont nombreux.

Vous pouvez utiliser la "chaîne de caractères.Le Format de la" méthode:

var user = GetUser();
var finishTime = GetFinishTime();
var fileUrl = GetFileUrl();
var signature = GetSignature();
string msg =
@"Dear {0},

Your job finished at {1} and your file is available for download at {2}.

Regards,

--
{3}";
msg = string.Format(msg, user, finishTime, fileUrl, signature);

Il vous permet de modifier le contenu dans le futur et est conviviale pour la localisation.

Vous pourriez utiliser des chaînes de caractères.Remplacer(...), éventuellement dans un chacun à travers tous les mots clés. Si il y a seulement quelques mots-clés que vous pouvez avoir sur une ligne comme ceci:

string myString = template.Replace("FirstName", "John").Replace("LastName", "Smith").Replace("FinishTime", DateTime.Now.ToShortDateString());

Ou vous pouvez utiliser les Regex.Remplacer(...), si vous avez besoin de quelque chose d'un peu plus puissant et avec plus d'options.

Lire ce article sur codeproject pour voir quelle chaîne de caractères de remplacement option est la plus rapide pour vous.

En fait, vous pouvez utiliser XSLT.
Vous créez un simple modèle XML:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:msxsl="urn:schemas-microsoft-com:xslt" exclude-result-prefixes="msxsl">
  <xsl:template match="TETT">
    <p>
       Dear <xsl:variable name="USERNAME" select="XML_PATH" />,

       Your job finished at <xsl:variable name="FINISH_TIME" select="XML_PATH" /> and your file is available for download at <xsl:variable name="FILE_URL" select="XML_PATH" />.

       Regards,
        -- 
       <xsl:variable name="SIGNATURE" select="XML_PATH" />
    </p>
</xsl:template>

Puis créer un XmlDocument pour effectuer la transformation à l'encontre de:
XmlDocument xmlDoc = new XmlDocument();

        XmlNode xmlNode = xmlDoc .CreateNode(XmlNodeType.Element, "EMAIL", null);
        XmlElement xmlElement= xmlDoc.CreateElement("USERNAME");
        xmlElement.InnerXml = username;
        xmlNode .AppendChild(xmlElement); ///repeat the same thing for all the required fields

        xmlDoc.AppendChild(xmlNode);

Après cela, appliquer la transformation:

        XPathNavigator xPathNavigator = xmlDocument.DocumentElement.CreateNavigator();
        StringBuilder sb = new StringBuilder();
        StringWriter sw = new StringWriter(sb);
        XmlTextWriter xmlWriter = new XmlTextWriter(sw);
        your_xslt_transformation.Transform(xPathNavigator, null, xmlWriter);
        return sb.ToString();

Très simple regex à base de solution. Prend en charge \nde style de caractère unique des séquences d'échappement et {Name}-style nommé variables.

Source

class Template
{
///<summary>Map of replacements for characters prefixed with a backward slash</summary>
private static readonly Dictionary<char, string> EscapeChars
= new Dictionary<char, string>
{
['r'] = "\r",
['n'] = "\n",
['\\'] = "\\",
['{'] = "{",
};
///<summary>Pre-compiled regular expression used during the rendering process</summary>
private static readonly Regex RenderExpr = new Regex(@"\\.|{([a-z0-9_.\-]+)}",
RegexOptions.IgnoreCase | RegexOptions.Compiled);
///<summary>Template string associated with the instance</summary>
public string TemplateString { get; }
///<summary>Create a new instance with the specified template string</summary>
///<param name="TemplateString">Template string associated with the instance</param>
public Template(string TemplateString)
{
if (TemplateString == null) {
throw new ArgumentNullException(nameof(TemplateString));
}
this.TemplateString = TemplateString;
}
///<summary>Render the template using the supplied variable values</summary>
///<param name="Variables">Variables that can be substituted in the template string</param>
///<returns>The rendered template string</returns>
public string Render(Dictionary<string, object> Variables)
{
return Render(this.TemplateString, Variables);
}
///<summary>Render the supplied template string using the supplied variable values</summary>
///<param name="TemplateString">The template string to render</param>
///<param name="Variables">Variables that can be substituted in the template string</param>
///<returns>The rendered template string</returns>
public static string Render(string TemplateString, Dictionary<string, object> Variables)
{
if (TemplateString == null) {
throw new ArgumentNullException(nameof(TemplateString));
}
return RenderExpr.Replace(TemplateString, Match => {
switch (Match.Value[0]) {
case '\\':
if (EscapeChars.ContainsKey(Match.Value[1])) {
return EscapeChars[Match.Value[1]];
}
break;
case '{':
if (Variables.ContainsKey(Match.Groups[1].Value)) {
return Variables[Match.Groups[1].Value].ToString();
}
break;
}
return string.Empty;
});
}
}

D'utilisation

var tplStr1 = @"Hello {Name},\nNice to meet you!";
var tplStr2 = @"This {Type} \{contains} \\ some things \\n that shouldn't be rendered";
var variableValues = new Dictionary<string, object>
{
["Name"] = "Bob",
["Type"] = "string",
};
Console.Write(Template.Render(tplStr1, variableValues));
//Hello Bob,
//Nice to meet you!
var template = new Template(tplStr2);
Console.Write(template.Render(variableValues));
//This string {contains} \ some things \n that shouldn't be rendered

Notes

• Je ne l'ai défini \n, \r, \\ et \{ les séquences d'échappement et codés en dur pour eux. Vous pouvez facilement ajouter plus ou rendre définissables par le consommateur.
• J'ai fait les noms de variable sensible à la casse, comme les choses de ce genre sont souvent présentés aux utilisateurs finaux ou à des non-programmeurs et je ne pense personnellement que la sensibilité à la casse sens de cas d'utilisation - c'est juste une chose de plus, ils peuvent se tromper et téléphone de vous plaindre (en plus en général si vous pensez que vous avez besoin de la casse des symboles de ce que vous avez vraiment besoin sont meilleurs noms de symbole). Pour les rendre sensibles à la casse, il suffit de retirer le RegexOptions.IgnoreCase drapeau.
• Je bande invalide les noms de variables et les séquences d'échappement de la chaîne de résultat. Laisser intact, retour Match.Value au lieu de la chaîne vide à la fin de la Regex.Replace de rappel. Vous pouvez également lancer une exception.
• J'ai utilisé {var} la syntaxe, mais cela pourrait interférer avec le natif interpolées syntaxe de la chaîne. Si vous souhaitez définir des modèles dans les littéraux de chaîne dans vous code, il peut être souhaitable de modifier la variable délimiteurs, par exemple %var% (regex \\.|%([a-z0-9_.\-]+)%) ou de certains autres éléments de la syntaxe de votre choix qui est le plus approprié au cas d'utilisation.

Si vous êtes le codage en VB.NET vous pouvez utiliser les littéraux XML. Si vous êtes le codage en C#, vous pouvez utiliser ShartDevelop d'avoir des fichiers en VB.NET dans le même projet que le code C#.