Was ist eine gute Möglichkeit, String Templating in .NET zu tun?

Hier ist die version für diejenigen, die kann verwenden Sie eine neue version von C#:

//add $ at start to mark string as template
var template = $"Your job finished at {FinishTime} and your file is available for download at {FileURL}."

In einer Linie - das ist jetzt eine vollständig unterstützte Sprache-Funktion (string-interpolation).

InformationsquelleAutor der Antwort Benjamin Gruenbaum

Können Sie mit der "string.Format" - Methode:

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);

Es erlaubt die änderung der Inhalte in der Zukunft und ist freundlich zur Lokalisierung.

InformationsquelleAutor der Antwort TcKs

Tatsächlich ist, können Sie mithilfe von XSLT.
Erstellen Sie eine einfache XML-Vorlage:

<?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>

Dann erstellen Sie ein XmlDocument-durchführen der transformation vor:
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);

Danach wenden Sie die 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();

InformationsquelleAutor der Antwort 0100110010101

Gibt es einige nette Hintergrundinformationen, die mit einer Umsetzung, Phil Haack blog: http://haacked.com/archive/2009/01/14/named-formats-redux.aspx

InformationsquelleAutor der Antwort Dave Cluderay

Eine sehr einfache regex-basierte Lösung. Unterstützt \n-style single character-escape-Sequenzen und {Name}-Stil mit dem Namen der Variablen.

Quelle

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;
        });
    }
}

Nutzung

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

• Ich habe nur definiert \n\r\\ und \{ escape-Sequenzen und hart-codiert. Sie könnte leicht fügen Sie mehr oder machen Sie definierbar durch den Verbraucher.
• Die ich gemacht habe Variablennamen groß-und Kleinschreibung, wie Sie Dinge wie diese sind oft an Endverbraucher/nicht-Programmierer und ich weiß nicht persönlich denke, dass groß-und Kleinschreibung Sinn machen, dass use-case - es ist nur eine weitere Sache, die Sie bekommen können es falsch und Mobiltelefon, mit dem Sie bis zu beklagen (plus in der Regel, wenn Sie denken, Sie brauchen die groß-Kleinschreibung symbol Namen was Sie wirklich brauchen, sind bessere Symbolnamen). Um Sie groß-und Kleinschreibung, entfernen Sie einfach die RegexOptions.IgnoreCase Flagge.
• Ich strip ungültige Variablennamen und escape-Sequenzen aus dem Ergebnis-string. Verlassen Sie intakt, zurück Match.Value statt der leeren Zeichenfolge am Ende der Regex.Replace Rückruf. Sie könnte auch eine Ausnahme werfen.
• Ich habe {var} syntax, aber dies kann zu Konflikten mit der einheimischen interpoliert string-syntax. Wenn Sie möchten, um Vorlagen in string-Literale im code, es könnte sinnvoll sein, ändern Sie die variable Trennzeichen sind z.B. %var% (regex \\.|%([a-z0-9_.\-]+)%) oder eine andere syntax Ihrer Wahl, welches ist besser geeignet, um die use-case.

InformationsquelleAutor der Antwort DaveRandom

Wenn Sie Codierung in VB.NET Sie können XML-Literale. Wenn Sie die Programmierung in C# können Sie ShartDevelop Dateien in VB.NET im selben Projekt C# - code.

InformationsquelleAutor der Antwort epitka