c# - Écrire du HTML dans une chaîne

Translate

J'ai un code comme celui-ci. Existe-t-il un moyen de faciliter la rédaction et la maintenance? Utilisation de C # .NET 3.5.

string header(string title)
{
    StringWriter s = new StringWriter();
    s.WriteLine("{0}","<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \"http://www.w3.org/TR/html4/strict.dtd\">");
    s.WriteLine("{0}", "<html>");
    s.WriteLine("<title>{0}</title>", title);
    s.WriteLine("{0}","<link rel=\"stylesheet\" type=\"text/css\" href=\"style.css\">");
    s.WriteLine("{0}", "</head>");
    s.WriteLine("{0}", "<body>");
    s.WriteLine("{0}", "");
}

Je pourrais aussi simplement écrire:

s.WriteLine("{0}", @"blah blah

many
new
lines
blah UHY#$&_#$_*@Y KSDSD<>\t\t\t\t\t\tt\t\t\\\t\t\t\t\\\h\th'\h't\th
hi
done"); 

Cela fonctionnera, mais je dois tout remplacer"avec"".

This question and all comments follow the "Attribution Required."

Toutes les réponses

lc.
Translate

Vous feriez probablement mieux d'utiliser unHtmlTextWriterou unXMLWriterqu'une plaineStringWriter. Ils se chargeront de s'échapper pour vous, ainsi que de s'assurer que le document est bien formé.

Cette pagemontre les bases de l'utilisation duHtmlTextWriterclasse, dont l'essentiel étant:

StringWriter stringWriter = new StringWriter();

using (HtmlTextWriter writer = new HtmlTextWriter(stringWriter))
{
    writer.AddAttribute(HtmlTextWriterAttribute.Class, classValue);
    writer.RenderBeginTag(HtmlTextWriterTag.Div); // Begin #1

    writer.AddAttribute(HtmlTextWriterAttribute.Href, urlValue);
    writer.RenderBeginTag(HtmlTextWriterTag.A); // Begin #2

    writer.AddAttribute(HtmlTextWriterAttribute.Src, imageValue);
    writer.AddAttribute(HtmlTextWriterAttribute.Width, "60");
    writer.AddAttribute(HtmlTextWriterAttribute.Height, "60");
    writer.AddAttribute(HtmlTextWriterAttribute.Alt, "");

    writer.RenderBeginTag(HtmlTextWriterTag.Img); // Begin #3
    writer.RenderEndTag(); // End #3

    writer.Write(word);

    writer.RenderEndTag(); // End #2
    writer.RenderEndTag(); // End #1
}
// Return the result.
return stringWriter.ToString();
La source
Translate

Lorsque je traite ce problème dans d'autres langues, j'opte pour une séparation du code et du HTML. Quelque chose comme:

1.) Créez un modèle HTML. utilisation[varname]espaces réservés pour marquer le contenu remplacé / inséré.
2.) Remplissez vos variables de modèle à partir d'un tableau ou d'une structure / mappage / dictionnaire

Write( FillTemplate(myHTMLTemplate, myVariables) ) # pseudo-code
La source
Translate

Je sais que vous avez posé des questions sur C #, mais si vous êtes prêt à utiliser un langage .Net, je recommande vivement Visual Basic pour ce problème précis. Visual Basic possède une fonctionnalité appelée littéraux XML qui vous permettra d'écrire du code comme celui-ci.

Module Module1

    Sub Main()

        Dim myTitle = "Hello HTML"
        Dim myHTML = <html>
                         <head>
                             <title><%= myTitle %></title>
                         </head>
                         <body>
                             <h1>Welcome</h1>
                             <table>
                                 <tr><th>ID</th><th>Name</th></tr>
                                 <tr><td>1</td><td>CouldBeAVariable</td></tr>
                             </table>
                         </body>
                     </html>

        Console.WriteLine(myHTML)
    End Sub

End Module

Cela vous permet d'écrire du HTML simple avec des trous d'expression dans l'ancien style ASP et rend votre code super lisible. Malheureusement, cette fonctionnalité n'est pas en C #, mais vous pouvez écrire un seul module en VB et l'ajouter comme référence à votre projet C #.

L'écriture dans Visual Studio permet également une indentation appropriée pour la plupart des littéraux XML et des ensembles d'expressions. L'indentation des trous d'expression est meilleure dans VS2010.

La source
Translate

Utilisez unXDocumentpour créer le DOM, puis écrivez-le en utilisant unXmlWriter. Cela vous donnera une notation merveilleusement concise et lisible ainsi qu'une sortie bien formatée.

Prenez cet exemple de programme:

using System.Xml;
using System.Xml.Linq;

class Program {
    static void Main() {
        var xDocument = new XDocument(
            new XDocumentType("html", null, null, null),
            new XElement("html",
                new XElement("head"),
                new XElement("body",
                    new XElement("p",
                        "This paragraph contains ", new XElement("b", "bold"), " text."
                    ),
                    new XElement("p",
                        "This paragraph has just plain text."
                    )
                )
            )
        );

        var settings = new XmlWriterSettings {
            OmitXmlDeclaration = true, Indent = true, IndentChars = "\t"
        };
        using (var writer = XmlWriter.Create(@"C:\Users\wolf\Desktop\test.html", settings)) {
            xDocument.WriteTo(writer);
        }
    }
}

Cela génère la sortie suivante:

<!DOCTYPE html >
<html>
    <head />
    <body>
        <p>This paragraph contains <b>bold</b> text.</p>
        <p>This paragraph has just plain text.</p>
    </body>
</html>
La source
Translate

Vous pourriez utiliserSystem.Xml.Linqobjets. Ils ont été totalement repensés de l'ancienSystem.Xmljours qui ont rendu la construction XML à partir de zéro vraiment ennuyeuse.

En dehors du doctype, je suppose, vous pouvez facilement faire quelque chose comme:

var html = new XElement("html",
    new XElement("head",
        new XElement("title", "My Page")
    ),
    new XElement("body",
        "this is some text"
    )
);
La source
Translate
return string.Format(@"<!DOCTYPE HTML PUBLIC ""-//W3C//DTD HTML 4.01//EN""      ""http://www.w3.org/TR/html4/strict.dtd"">
<html>
<title>{0}</title>
<link rel=""stylesheet"" type=""text/css"" href=""style.css"">
</head>
<body>
", title);
La source
Translate

Le moyen le plus simple consiste à utiliser un objet XmlWriter. Cela peut être utilisé pour produire du HTML valide et s'occupera de toutes les mauvaises séquences d'échappement pour vous.

La source
Translate

Vous pouvez utiliserModèles T4pour générer Html (ou tout autre) à partir de votre code. regarde ça:http://msdn.microsoft.com/en-us/library/ee844259.aspx

La source
Translate

Si vous cherchez à créer un document HTML similaire à la façon dont vous créeriez un document XML en C #, vous pouvez essayer la bibliothèque open source de Microsoft, lePack d'agilité HTML.

Il fournit un objet HtmlDocument qui a une API très similaire à laSystem.Xml.XmlDocumentclasse.

La source
Translate

Vous pouvez utiliser ASP.NET pour générer votre HTML en dehors du contexte des pages Web.Voici un articlecela montre comment cela peut être fait.

La source
Translate

Vous pouvez utiliser des bibliothèques open-source tierces pour générer du code HTML vérifié (X) à typage fort, tel queCadre CityLizardou Sharp DOM.

Mettre à jourPar exemple

html
    [head
        [title["Title of the page"]]
        [meta_(
            content: "text/html;charset=UTF-8",
            http_equiv: "Content-Type")
        ]
        [link_(href: "css/style.css", rel: "stylesheet", type: "text/css")]
        [script_(type: "text/javascript", src: "/JavaScript/jquery-1.4.2.min.js")]
    ]
    [body
        [div
            [h1["Test Form to Test"]]
            [form_(action: "post", id: "Form1")
                [div
                    [label["Parameter"]]
                    [input_(type: "text", value: "Enter value")]
                    [input_(type: "submit", value: "Submit!")]
                ]
            ]
            [div
                [p["Textual description of the footer"]]
                [a_(href: "http://google.com/")
                    [span["You can find us here"]]
                ]
                [div["Another nested container"]]
            ]
        ]
    ];
La source
Translate

Ce n'est pas une solution générique, cependant, si votre objectif est d'avoir ou de maintenir des modèles de courrier électronique, System.Web a une classe intégrée appeléeMailDefinition. Cette classe est utilisée par les contrôles d'appartenance ASP.NET pour créer des e-mails HTML.

Est-ce que le même genre de «chaîne remplace» les choses comme mentionné ci-dessus, mais emballe le tout dans un MailMessage pour vous.

Voici un exemple de MSDN:

ListDictionary replacements = new ListDictionary();
replacements.Add("<%To%>",sourceTo.Text);
replacements.Add("<%From%>", md.From);
System.Net.Mail.MailMessage fileMsg;
fileMsg = md.CreateMailMessage(toAddresses, replacements, emailTemplate, this); 
return fileMsg;
La source
Translate

Avec l'introduction de Razor dans ASP.net MVC, la meilleure façon d'écrire du HTML en C # est d'utiliser Razor Engine.

string templatePath = [email protected]"{Directory.GetCurrentDirectory()}\EmailTemplates"; 

IRazorLightEngine engine = EngineFactory.CreatePhysical(templatePath); 

var model = new Notification 
{ 
       Name = "Jone", 
       Title = "Test Email", 
       Content = "This is a test" 
}; 

string result = engine.Parse("template.cshtml", model); 

Modèle:

<h2>Dear @Model.Name, you have a notification.</h2> 

<h1>@Model.Title</h1> 
<p>@Model.Content</p> 

<p>Date:@DateTime.Now</p> 

Pour un exemple complet, voirici

La source
Translate

Vous pouvez écrire vos propres classes avec sa méthode Render, et d'autres attributs, pour éviter un grand désordre si vous l'utilisez beaucoup, puis utiliser également HTMLWriter ou xmlwriter. Cette logique est utilisée dans les pages asp.net, vous pouvez hériter de webControl et remplacer leméthode de rendu, ce qui est idéal si vous développez des contrôles côté serveur.
Cepourrait être un bon exemple.

Cordialement

La source
Translate

Cela dépend vraiment de ce que vous recherchez, et plus précisément du type de performance que vous devez vraiment offrir.

J'ai vu des solutions admirables pour le développement HTML fortement typé (modèles de contrôle complets, que ce soit des contrôles Web ASP.NET ou similaires) qui ajoutent simplement une complexité incroyable à un projet. Dans d'autres situations, c'est parfait.

Par ordre de préférence dans le monde C #,

  • Contrôles Web ASP.NET
  • Primitives ASP.NET et contrôles HTML
  • XmlWriter et / ou HtmlWriter
  • Si vous faites du développement Silverlight avec l'interopérabilité HTML, pensez à quelque chose de fortement typé commetexte du lien
  • StringBuilder et autres super primitives
La source
Translate

J'ai écrit ces cours qui m'ont bien servi. C'est simple mais pragmatique.

public class HtmlAttribute
{
    public string Name { get; set; }
    public string Value { get; set; }

    public HtmlAttribute(string name) : this(name, null) { }

    public HtmlAttribute(
        string name,
        string @value)
    {
        this.Name = name;
        this.Value = @value;
    }

    public override string ToString()
    {
        if (string.IsNullOrEmpty(this.Value))
            return this.Name;

        if (this.Value.Contains('"'))
            return string.Format("{0}='{1}'", this.Name, this.Value);

        return string.Format("{0}=\"{1}\"", this.Name, this.Value);
    }
}

public class HtmlElement
{
    protected List<HtmlAttribute> Attributes { get; set; }
    protected List<object> Childs { get; set; }
    public string Name { get; set; }
    protected HtmlElement Parent { get; set; }

    public HtmlElement() : this(null) { }

    public HtmlElement(string name, params object[] childs)
    {
        this.Name = name;
        this.Attributes = new List<HtmlAttribute>();
        this.Childs = new List<object>();

        if (childs != null && childs.Length > 0)
        {
            foreach (var c in childs)
            {
                Add(c);
            }
        }
    }

    public void Add(object o)
    {
        var a = o as HtmlAttribute;
        if (a != null)
            this.Attributes.Add(a);
        else
        {
            var h = o as HtmlElement;
            if (h != null && !string.IsNullOrEmpty(this.Name))
            {
                h.Parent = this;
                this.Childs.Add(h);
            }
            else
                this.Childs.Add(o);
        }
    }

    public override string ToString()
    {
        var result = new StringBuilder();

        if (!string.IsNullOrEmpty(this.Name))
        {
            result.Append(string.Format("<{0}", this.Name));
            if (this.Attributes.Count > 0)
            {
                result.Append(" ");
                foreach (var attr in this.Attributes)
                {
                    result.Append(attr.ToString());
                    result.Append(" ");
                }

                result = new StringBuilder(result.ToString().TrimEnd(' '));
            }

            if (this.Childs.Count == 0)
            {
                result.Append(" />");
            }
            else
            {
                result.AppendLine(">");

                foreach (var c in this.Childs)
                {
                    var cParts = c.ToString().Split('\n');

                    foreach (var p in cParts)
                    {
                        result.AppendLine(string.Format("{0}", p));
                    }
                }

                result.Append(string.Format("</{0}>", this.Name));
            }
        }
        else
        {
            foreach (var c in this.Childs)
            {
                var cParts = c.ToString().Split('\n');

                foreach (var p in cParts)
                {
                    result.AppendLine(string.Format("{0}", p));
                }
            }
        }

        var head = GetHeading(this);

        var ps = result.ToString().Split('\n');
        return string.Join("\r\n", (from p in ps select head + p.TrimEnd('\r')).ToArray());
    }

    string GetHeading(HtmlElement h)
    {
        if (h.Parent != null)
            return "    ";
        else
            return string.Empty;
    }
}
La source
MMA
Translate

HSharp est une bibliothèque utilisée pour analyser facilement et rapidement un langage de balisage comme HTML. Installer:PM> Install-Package Obisoft.HSharp

        var Document = new HDoc(DocumentOptions.BasicHTML);
        Document["html"]["body"].AddChild("div");
        Document["html"]["body"]["div"].AddChild("a", new HProp("href", "/#"));
        Document["html"]["body"]["div"].AddChild("table");
        Document["html"]["body"]["div"]["table"].AddChildren(
         new HTag("tr"),
         new HTag("tr", "SomeText"),
         new HTag("tr", new HTag("td")));
        var Result = Document.GenerateHTML();
        Console.WriteLine(Result);

et sortie:

<html>
<head>
<meta charset="utf-8"></meta><title>
Example </title>
</head>
<body>
<div>
<a href="/#"></a><table>
<tr></tr><tr>
SomeText </tr>
<tr>
<td></td></tr>
</table>
</div>
</body>
</html>
La source
Translate

Je cherchais quelque chose qui ressemblait à jquery pour générer dom en C # (je n'ai pas besoin d'analyser). Malheureusement, pas de chance pour trouver une solution légère, j'ai donc créé cette classe simple héritée de System.Xml.Linq.XElement. La caractéristique clé est que vous pouvez chaîner l'opérateur comme lorsque vous utilisez jquery en javascript pour qu'il soit plus fluide. Ce n'est pas complet mais il fait ce dont j'ai besoin et s'il y a de l'intérêt, je peux démarrer un git.

public class DomElement : XElement
{
    public DomElement(string name) : base(name)
    {
    }

    public DomElement(string name, string value) : base(name, value)
    {
    }

    public DomElement Css(string style, string value)
    {
        style = style.Trim();
        value = value.Trim();
        var existingStyles = new Dictionary<string, string>();
        var xstyle = this.Attribute("style");
        if (xstyle != null)
        {
            foreach (var s in xstyle.Value.Split(';'))
            {
                var keyValue = s.Split(':');
                existingStyles.Add(keyValue[0], keyValue.Length < 2 ? null : keyValue[1]);
            }
        }

        if (existingStyles.ContainsKey(style))
        {
            existingStyles[style] = value;
        }
        else
        {
            existingStyles.Add(style, value);
        }

        var styleString = string.Join(";", existingStyles.Select(s => $"{s.Key}:{s.Value}"));
        this.SetAttributeValue("style", styleString);

        return this;
    }

    public DomElement AddClass(string cssClass)
    {
        var existingClasses = new List<string>();
        var xclass = this.Attribute("class");
        if (xclass != null)
        {
            existingClasses.AddRange(xclass.Value.Split());
        }

        var addNewClasses = cssClass.Split().Where(e => !existingClasses.Contains(e));
        existingClasses.AddRange(addNewClasses);

        this.SetAttributeValue("class", string.Join(" ", existingClasses));
        return this;
    }

    public DomElement Text(string text)
    {
        this.Value = text;
        return this;
    }

    public DomElement Append(string text)
    {
        this.Add(text);
        return this;
    }

    public DomElement Append(DomElement child)
    {
        this.Add(child);
        return this;
    }
}

Échantillon:

void Main()
{
    var html = new DomElement("html")
        .Append(new DomElement("head"))
        .Append(new DomElement("body")
            .Append(new DomElement("p")
                .Append("This paragraph contains")
                .Append(new DomElement("b", "bold"))
                .Append(" text.")
                )
            .Append(new DomElement("p").Text("This paragraph has just plain text"))
            )
        ;

    html.ToString().Dump();

    var table = new DomElement("table").AddClass("table table-sm").AddClass("table-striped")
            .Append(new DomElement("thead")
                .Append(new DomElement("tr")
                    .Append(new DomElement("td").Css("padding-left", "15px").Css("color", "red").Css("color", "blue")
                        .AddClass("from-now")
                        .Append(new DomElement("div").Text("Hi there"))
                        .Append(new DomElement("div").Text("Hey there"))
                        .Append(new DomElement("div", "Yo there"))
                        )
                )
            )
        ;
    table.ToString().Dump();
}

sortie du code ci-dessus:

<html>
  <head />
  <body>
    <p>This paragraph contains<b>bold</b> text.</p>
    <p>This paragraph has just plain text</p>
  </body>
</html>
<table class="table table-sm table-striped">
  <thead>
    <tr>
      <td style="padding-left:15px;color:blue" class="from-now">
        <div>Hi there</div>
        <div>Hey there</div>
        <div>Yo there</div>
      </td>
    </tr>
  </thead>
</table>
La source
Leave a Reply
You must be logged in to post a answer.
A propos de l'auteur