c# - Írj HTML-t a karakterláncra

Translate

Van ilyen kódom. Van-e mód arra, hogy megkönnyítse az írást és a karbantartást? A C # .NET 3.5 használata.

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

Írhatnék is:

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

Működni fog, de le kell cserélnem az összeset"val vel"".

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

Minden válasz

lc.
Translate

Valószínűleg jobban jár, ha használ egyHtmlTextWritervagy egyXMLWritermint egy síkságStringWriter. Ők gondoskodnak a menekülésről az Ön számára, valamint arról, hogy a dokumentum megfelelő formában legyen.

Ez az oldalbemutatja aHtmlTextWriterosztály, amelynek lényege:

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();
Forrás
Translate

Amikor más nyelvekkel foglalkozom ezzel a problémával, elválasztom a kódot és a HTML-t. Valami hasonló:

1.) Hozzon létre egy HTML sablont. használat[varname]helyőrzők a kicserélt / beillesztett tartalom jelölésére.
2.) Töltse ki a sablonváltozókat egy tömbből vagy szerkezetből / leképezésből / szótárból

Write( FillTemplate(myHTMLTemplate, myVariables) ) # pseudo-code
Forrás
Translate

Tudom, hogy a C # -val kapcsolatban kérdezett, de ha hajlandó bármilyen .Net nyelvet használni, akkor nagyon ajánlom a Visual Basic alkalmazást ehhez a problémához. A Visual Basic rendelkezik az XML Literals nevű funkcióval, amely lehetővé teszi, hogy ilyen kódot írjon.

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

Ez lehetővé teszi, hogy egyenes HTML-t írjon, kifejezési lyukakkal a régi ASP stílusban, és szuper olvashatóvá teszi a kódot. Sajnos ez a szolgáltatás nem szerepel a C # fájlban, de írhat egyetlen modult a VB-be, és hozzáadhatja referenciaként a C # projektjéhez.

A Visual Studio-ban történő írás lehetővé teszi a megfelelő behúzást a legtöbb XML-literál és kifejezés-egész számára. A kifejezési lyukak behúzása jobb a VS2010-ben.

Forrás
Translate

Használjon egyXDocumenta DOM létrehozásához, majd írd ki egyXmlWriter. Ez csodálatosan tömör és olvasható jelölést, valamint szépen formázott kimenetet eredményez.

Vegyük ezt a mintaprogramot:

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

Ez a következő kimenetet generálja:

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

HasználhatnádSystem.Xml.Linqtárgyakat. Teljesen átalakították a régitőlSystem.Xmlnapok, amelyek nagyon idegesítővé tették az XML elkészítését a semmiből.

Azt hiszem, a doctype-n kívül könnyedén megteheted a következőket:

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

A legegyszerűbb módszer az XmlWriter objektum használata. Ez felhasználható érvényes HTML előállítására, és gondoskodik az összes csúnya menekülési szekvenciáról.

Forrás
Translate

Te tudod használniT4 sablonokHtml (vagy bármely más) előállításához a kódodból. ezt nézd:http://msdn.microsoft.com/en-us/library/ee844259.aspx

Forrás
Translate

Ha olyan HTML dokumentumot szeretne létrehozni, amely hasonló ahhoz, ahogyan létrehozna egy XML dokumentumot a C # formátumban, akkor kipróbálhatja a Microsoft nyílt forráskódú könyvtárát, aHtml Agility Pack.

Olyan HtmlDocument objektumot biztosít, amely nagyon hasonló API-val rendelkezikSystem.Xml.XmlDocumentosztály.

Forrás
Translate

Az ASP.NET segítségével létrehozhatja HTML-jét a weboldalak kontextusán kívül.Itt egy cikkez megmutatja, hogyan lehet megtenni.

Forrás
Translate

Használhat néhány harmadik féltől származó nyílt forráskódú könyvtárat erős, gépelt, ellenőrzött (X) HTML-ek előállításához, példáulCityLizard Frameworkvagy Sharp DOM.

FrissítésPéldául

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"]]
            ]
        ]
    ];
Forrás
Translate

Ez nem általános megoldás, azonban ha a tanulónak e-mail sablonokat kell tartania vagy fenntartania, akkor a System.Web-nek van egy beépített osztálya,MailDefinition. Ezt az osztályt használják az ASP.NET tagsági vezérlők HTML e-mailek létrehozására.

Helyettesíti-e a fent említett dolgokat, de az egészet egy MailMessage-be csomagolja az Ön számára.

Íme egy példa az MSDN-től:

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;
Forrás
Translate

A Razor bevezetésével az ASP.net MVC-ben a HTML C # formátumban történő írásának legjobb módja a 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); 

Sablon:

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

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

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

A teljes mintát lásditt

Forrás
Translate

Írhatná a saját osztályait a Render módszerével és egy másik attribútummal, hogy elkerülje a nagy rendetlenséget, ha sokat használja, majd használja a HTMLWritert vagy az xmlwritert is. Ezt a logikát használják az asp.net oldalakon. Örökölhet a webvezérlésből, és felülírhatja arenderelési módszer, ami nagyszerű, ha szerveroldali vezérlőket fejlesztesz.
Ezjó példa lehet.

Üdvözlettel

Forrás
Translate

Nagyon függ attól, hogy mire készülsz, és konkrétan attól, hogy milyen teljesítményt kell igazán felajánlanod.

Csodálatos megoldásokat láttam az erősen tipizált HTML fejlesztéshez (teljes vezérlési modellek, legyenek azok az ASP.NET webvezérlők, vagy hasonlóak), amelyek csak elképesztő bonyolultságot adnak a projektnek. Más helyzetekben tökéletes.

A C # világ preferencia sorrendjében

  • ASP.NET webes vezérlők
  • ASP.NET primitívek és HTML vezérlők
  • XmlWriter és / vagy HtmlWriter
  • Ha Silverlight fejlesztést végez HTML interoperabilitással, vegyen fontolóra valami hasonlótlink szövege
  • StringBuilder és más szuper primitívek
Forrás
Translate

Ezeket az osztályokat írtam, amelyek jól szolgáltak nekem. Ez egyszerű, de pragmatikus.

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;
    }
}
Forrás
MMA
Translate

A HSharp egy olyan könyvtár, amelyet könnyen és gyorsan elemezhet a jelölő nyelv, például a HTML. Telepítés: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);

és kimenet:

<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>
Forrás
Translate

Valami olyasmit kerestem, amelyik jquery-nek tűnt a domén létrehozásához a C # -ben (nem kell elemeznem). Sajnos nincs szerencséje a könnyű megoldás megtalálásában, ezért létrehoztam ezt az egyszerű osztályt, amelyet a System.Xml.Linq.XElement örökölt. A legfontosabb jellemző az, hogy az operátort úgy láncolhatja, mint amikor a jquery-t használja a javascriptben, így folyékonyabb. Ez nem teljesen szerepel, de megteszi, amire szükségem van, és ha van érdeklődés, elkezdhetek egy git-et.

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

Minta:

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

kimenet a fenti kódból:

<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>
Forrás
Leave a Reply
You must be logged in to post a answer.
A szerzőről