c# - Scrivi HTML su stringa

Translate

Ho un codice come questo. C'è un modo per semplificare la scrittura e la manutenzione? Utilizzo di 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}", "");
}

Potrei anche scrivere:

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

Funzionerà, ma devo sostituire tutto"con"".

fonte

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

Tutte le risposte

lc.

Translate

Probabilmente stai meglio usando un fileHtmlTextWritero unXMLWriterdi una pianuraStringWriter. Si prenderanno cura di scappare per te, oltre ad assicurarsi che il documento sia ben formato.

Questa paginamostra le basi dell'utilizzo diHtmlTextWriterclasse, il cui succo è:

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

fonte

SpliFF

Translate

Quando mi occupo di questo problema in altre lingue scelgo una separazione tra codice e HTML. Qualcosa di simile a:

1.) Crea un modello HTML. uso[varname]segnaposto per contrassegnare il contenuto sostituito / inserito.
2.) Riempi le variabili del tuo modello da un array o da una struttura / mappatura / dizionario

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

fonte

Jim Wallace

Translate

So che hai chiesto informazioni su C #, ma se sei disposto a utilizzare qualsiasi linguaggio .Net, ti consiglio vivamente Visual Basic per questo problema esatto. Visual Basic ha una funzionalità chiamata XML Literals che ti consentirà di scrivere codice come questo.

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

Ciò ti consente di scrivere HTML semplice con buchi di espressione nel vecchio stile ASP e rende il tuo codice super leggibile. Sfortunatamente questa funzionalità non è in C #, ma potresti scrivere un singolo modulo in VB e aggiungerlo come riferimento al tuo progetto C #.

La scrittura in Visual Studio consente inoltre un rientro appropriato per la maggior parte dei letterali XML e degli interi di espressioni. L'indentazione per i fori di espressione è migliore in VS2010.

fonte

Daniel Wolf

Translate

Usa un fileXDocumentper creare il DOM, quindi scriverlo utilizzando un fileXmlWriter. Questo ti darà una notazione meravigliosamente concisa e leggibile così come un output ben formattato.

Prendi questo programma di esempio:

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

Questo genera il seguente output:

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

fonte

Josh

Translate

Potresti usareSystem.Xml.Linqoggetti. Sono stati completamente ridisegnati dal vecchioSystem.Xmlgiorni che hanno reso la creazione di XML da zero davvero fastidiosa.

Oltre al doctype immagino, potresti facilmente fare qualcosa come:

var html = new XElement("html",
    new XElement("head",
        new XElement("title", "My Page")
    ),
    new XElement("body",
        "this is some text"
    )
);

fonte

Jimmy

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

fonte

JaredPar

Translate

Il modo più semplice è usare un oggetto XmlWriter. Questo può essere usato per produrre HTML valido e si prenderà cura di tutte le brutte sequenze di escape per te.

http://msdn.microsoft.com/en-us/library/system.xml.xmlwriter.aspx

fonte

oleg wx

Translate

Puoi usareModelli T4per generare Html (o qualsiasi altro) dal tuo codice. guarda questo:http://msdn.microsoft.com/en-us/library/ee844259.aspx

fonte

Dan Herbert

Translate

Se stai cercando di creare un documento HTML simile a come creeresti un documento XML in C #, potresti provare la libreria open source di Microsoft, ilHtml Agility Pack.

Fornisce un oggetto HtmlDocument che ha un'API molto simile aSystem.Xml.XmlDocumentclasse.

fonte

Jacob

Translate

È possibile utilizzare ASP.NET per generare il codice HTML al di fuori del contesto delle pagine web.Ecco un articoloche mostra come si può fare.

fonte

Sergey Shandar

Translate

È possibile utilizzare alcune librerie open source di terze parti per generare HTML verificato (X) fortemente tipizzato, comeCityLizard Frameworko Sharp DOM.

AggiornarePer esempio

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

fonte

Brendan Kowitz

Translate

Questa non è una soluzione generica, tuttavia, se il tuo pupo deve avere o mantenere modelli di posta elettronica, System.Web ha una classe incorporata chiamataMailDefinition. Questa classe viene utilizzata dai controlli di appartenenza di ASP.NET per creare messaggi di posta elettronica HTML.

Fa lo stesso tipo di "sostituzione di stringa" come menzionato sopra, ma racchiude tutto in un MailMessage per te.

Ecco un esempio da 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;

fonte

Greg Gum

Translate

Con l'introduzione di Razor in ASP.net MVC, il modo migliore per scrivere HTML in C # è con il motore Razor.

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

Modello:

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

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

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

Per un esempio completo, vedereQui

fonte

Matias

Translate

Potresti scrivere le tue classi con il suo metodo Render e altri attributi, per evitare un gran casino se lo usi molto, e quindi usare anche HTMLWriter o xmlwriter. Questa logica viene utilizzata nelle pagine asp.net, è possibile ereditare da webControl e sovrascrivere ilmetodo di rendering, che è ottimo se stai sviluppando controlli lato server.
Questopotrebbe essere un buon esempio.

Saluti

fonte

Jeff Wilcox

Translate

Dipende davvero da cosa stai cercando e, in particolare, dal tipo di performance che devi davvero offrire.

Ho visto soluzioni ammirevoli per lo sviluppo di HTML fortemente tipizzato (modelli di controllo completi, siano essi controlli Web ASP.NET o simili) che aggiungono semplicemente una straordinaria complessità a un progetto. In altre situazioni è perfetto.

In ordine di preferenza nel mondo C #,

Controlli Web ASP.NET
Primitive ASP.NET e controlli HTML
XmlWriter e / o HtmlWriter
Se si esegue lo sviluppo di Silverlight con l'interoperabilità HTML, si consideri qualcosa di fortemente tipizzato cometesto del collegamento
StringBuilder e altre super primitive

fonte

Kaveh Shahbazian

Translate

Ho scritto queste lezioni che mi hanno servito bene. È semplice ma pragmatico.

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

fonte

MMA

Translate

HSharp è una libreria utilizzata per analizzare il linguaggio di markup come HTML in modo semplice e veloce. Installare: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);

e output:

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

fonte

howardlo

Translate

Stavo cercando qualcosa che assomigliasse a jquery per generare dom in C # (non ho bisogno di analizzare). Sfortunatamente non ho avuto fortuna nel trovare una soluzione leggera, quindi ho creato questa semplice classe ereditata da System.Xml.Linq.XElement. La caratteristica chiave è che puoi concatenare l'operatore come quando usi jquery in javascript, quindi è più scorrevole. Non è completo ma fa quello che mi serve e se c'è interesse posso avviare 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;
    }
}

Campione:

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

uscita dal codice sopra:

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

fonte

You must be logged in to post a answer.

Circa l'autore

Anonymous

c# - Scrivi HTML su stringa

Tutte le risposte

Leave a Reply

Circa l'autore

Problemi simili

Category