c# - Napište HTML do řetězce

Translate

Mám takový kód. Existuje způsob, jak usnadnit psaní a údržbu? Pomocí 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}", "");
}

Také bych mohl napsat:

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

Bude to fungovat, ale musím vše nahradit"s"".

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

Všechny odpovědi

lc.
Translate

Pravděpodobně je lepší použítHtmlTextWriterneboXMLWriternež pláňStringWriter. Postarají se o útěk a zajistí, aby byl dokument správně vytvořen.

Tato stránkaukazuje základy používáníHtmlTextWritertřída, jejíž podstata je:

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();
Zdroj
Translate

Když se s tímto problémem zabývám v jiných jazycích, snažím se o oddělení kódu a HTML. Něco jako:

1.) Vytvořte šablonu HTML. použití[varname]zástupné symboly k označení nahrazeného / vloženého obsahu.
2.) Vyplňte své proměnné šablony z pole nebo struktury / mapování / slovníku

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

Vím, že jste se zeptali na C #, ale pokud jste ochotni použít jakýkoli jazyk .Net, pak pro tento přesný problém velmi doporučuji Visual Basic. Visual Basic má funkci nazvanou XML Literals, která vám umožní takto psát kód.

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

To vám umožní psát přímo HTML s výrazovými mezerami ve starém stylu ASP a váš kód bude super čitelný. Tato funkce bohužel není v C #, ale můžete napsat jeden modul ve VB a přidat jej jako odkaz na svůj C # projekt.

Zápis v sadě Visual Studio také umožňuje správné odsazení pro většinu XML literálů a celých výrazů. Odsazení pro díry výrazu je ve VS2010 lepší.

Zdroj
Translate

PoužijteXDocumentvytvořte DOM, poté jej vypište pomocíXmlWriter. To vám poskytne úžasně stručnou a čitelnou notaci i pěkně naformátovaný výstup.

Vezměte tento ukázkový program:

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

To generuje následující výstup:

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

Můžete použítSystem.Xml.Linqpředměty. Byli úplně přepracováni ze staréhoSystem.Xmldny, díky nimž byla konstrukce XML od nuly opravdu otravná.

Kromě doctype myslím, že byste mohli snadno udělat něco jako:

var html = new XElement("html",
    new XElement("head",
        new XElement("title", "My Page")
    ),
    new XElement("body",
        "this is some text"
    )
);
Zdroj
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);
Zdroj
Translate

Nejpřímějším způsobem je použití objektu XmlWriter. To lze použít k vytvoření platného HTML a postará se o všechny ošklivé únikové sekvence.

Zdroj
Translate

Můžeš použítŠablony T4pro generování Html (nebo libovolného) z vašeho kódu. viz toto:http://msdn.microsoft.com/en-us/library/ee844259.aspx

Zdroj
Translate

Pokud hledáte vytvoření dokumentu HTML podobného tomu, jak byste vytvořili dokument XML v C #, můžete zkusit knihovnu Microsoftu s otevřeným zdrojovým kódem,Html balíček agility.

Poskytuje objekt HtmlDocument, který má velmi podobné API jakoSystem.Xml.XmlDocumenttřída.

Zdroj
Translate

Můžete použít ASP.NET ke generování kódu HTML mimo kontext webových stránek.Tady je článekkterý ukazuje, jak se to dá udělat.

Zdroj
Translate

K generování silných typově ověřených (X) HTML, jako je například, můžete použít některé knihovny třetích stran s otevřeným zdrojovým kódemCityLizard Frameworknebo Sharp DOM.

AktualizaceNapříklad

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"]]
            ]
        ]
    ];
Zdroj
Translate

Nejedná se o obecné řešení, pokud má vaše pupose mít nebo udržovat e-mailové šablony, pak má System.Web integrovanou třídu s názvemMailDefinition. Tuto třídu používají ovládací prvky členství ASP.NET k vytváření e-mailů HTML.

Nahrazuje stejný druh věcí „řetězec“, jak je uvedeno výše, ale zabalí to vše do MailMessage pro vás.

Zde je příklad z 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;
Zdroj
Translate

Se zavedením Razor v ASP.net MVC je nejlepším způsobem, jak psát HTML v C #, 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); 

Šablona:

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

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

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

Kompletní ukázku najdete natady

Zdroj
Translate

Mohli byste napsat své vlastní třídy pomocí metody Render a dalších atributů, abyste se vyhnuli velkému nepořádku, pokud jej hodně používáte, a pak použijte také HTMLWriter nebo xmlwriter. Tato logika se používá na stránkách asp.net, můžete zdědit z webControl a přepsatmetoda vykreslení, což je skvělé, pokud vyvíjíte ovládací prvky na straně serveru.
Tentomůže být dobrým příkladem.

pozdravy

Zdroj
Translate

Opravdu záleží na tom, co se chystáte, a konkrétně, jaký výkon opravdu potřebujete nabídnout.

Viděl jsem obdivuhodná řešení pro vývoj HTML se silným typem (kompletní řídicí modely, ať už jsou to webové ovládací prvky ASP.NET nebo podobné), které projektu jen dodávají úžasnou složitost. V jiných situacích je to perfektní.

V pořadí preferencí ve světě C #,

  • Webové ovládací prvky ASP.NET
  • Primitiva ASP.NET a ovládací prvky HTML
  • XmlWriter a / nebo HtmlWriter
  • Pokud provádíte vývoj Silverlight s interoperabilitou HTML, zvažte něco silně napsaného typutext odkazu
  • StringBuilder a další super primitiva
Zdroj
Translate

Napsal jsem tyto hodiny, které mi dobře sloužily. Je to jednoduché, ale pragmatické.

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;
    }
}
Zdroj
MMA
Translate

HSharp je knihovna používaná k snadné a rychlé analýze značkovacího jazyka, jako je HTML. Nainstalujte: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);

a výstup:

<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>
Zdroj
Translate

Hledal jsem něco, co vypadalo jako jquery pro generování dom v C # (nepotřebuji analyzovat). Bohužel štěstí při hledání lehkého řešení, tak jsem vytvořil tuto jednoduchou třídu, která se dědí z System.Xml.Linq.XElement. Klíčovou vlastností je, že můžete operátora zřetězit, jako když používáte jquery v JavaScriptu, takže je plynulejší. Není plně funkční, ale dělá to, co potřebuji, a pokud je zájem, můžu spustit 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;
    }
}

Vzorek:

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

výstup z výše uvedeného kódu:

<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>
Zdroj
Leave a Reply
You must be logged in to post a answer.
O autorovi