c# - HTML को string में लिखें

lc.

Translate

आप शायद एक का उपयोग कर बेहतर कर रहे हैंHtmlTextWriterया एXMLWriterसादे सेStringWriter। वे आपके लिए भागने की देखभाल करेंगे, साथ ही यह सुनिश्चित करेंगे कि दस्तावेज़ अच्छी तरह से बना है।

यह पन्नाका उपयोग करने की मूल बातें दिखाता हैHtmlTextWriterवर्ग, जिसके होने का सार:

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

स्रोत

SpliFF

Translate

जब मैं अन्य भाषाओं में इस समस्या से निपटता हूं तो मैं कोड और HTML के अलगाव के लिए जाता हूं। कुछ इस तरह:

1.) एक HTML टेम्पलेट बनाएँ। उपयोग[varname]प्लेसहोल्डर्स को प्रतिस्थापित / सम्मिलित सामग्री को चिह्नित करने के लिए।
2.) एक सरणी या संरचना / मानचित्रण / शब्दकोश से अपने टेम्पलेट चर भरें

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

स्रोत

Jim Wallace

Translate

मुझे पता है कि आपने C # के बारे में पूछा था, लेकिन यदि आप किसी भी .Net भाषा का उपयोग करने के लिए तैयार हैं, तो मैं इस सटीक समस्या के लिए Visual Basic की अत्यधिक अनुशंसा करता हूं। विज़ुअल बेसिक में XML लिटरल्स नामक एक फीचर है जो आपको इस तरह कोड लिखने की अनुमति देगा।

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

यह आपको पुराने एएसपी शैली में अभिव्यक्ति छेद के साथ सीधे HTML लिखने की अनुमति देता है और आपके कोड को सुपर पठनीय बनाता है। दुर्भाग्य से यह सुविधा C # में नहीं है, लेकिन आप VB में एक एकल मॉड्यूल लिख सकते हैं और इसे अपने C # प्रोजेक्ट के संदर्भ में जोड़ सकते हैं।

विजुअल स्टूडियो में लेखन भी अधिकांश XML साहित्य और अभिव्यक्ति के लिए उचित इंडेंटेशन की अनुमति देता है। VS2010 में अभिव्यक्ति छेद के लिए इंडेंटेशन बेहतर है।

स्रोत

Daniel Wolf

Translate

एक का उपयोग करेंXDocumentDOM को बनाने के लिए, फिर इसे a का उपयोग करके लिखेंXmlWriter। यह आपको आश्चर्यजनक रूप से संक्षिप्त और पठनीय अंकन के साथ-साथ अच्छी तरह से स्वरूपित आउटपुट देगा।

यह नमूना कार्यक्रम लें:

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

यह निम्न आउटपुट उत्पन्न करता है:

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

स्रोत

Josh

Translate

आप उपयोग कर सकते हैंSystem.Xml.Linqवस्तुएं। उन्हें पुराने से पूरी तरह से बदल दिया गया थाSystem.Xmlवे दिन जो खरोंच से XML का निर्माण करते हैं, वास्तव में कष्टप्रद होते हैं।

मेरे अनुमान के अलावा, आप आसानी से ऐसा कुछ कर सकते हैं:

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

स्रोत

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

स्रोत

JaredPar

Translate

XmlWriter ऑब्जेक्ट का उपयोग करने के लिए सबसे सीधा तरीका है। यह वैध HTML का उत्पादन करने के लिए इस्तेमाल किया जा सकता है और आप के लिए सभी बुरा भागने दृश्यों का ख्याल रखेगा।

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

स्रोत

oleg wx

Translate

आप उपयोग कर सकते हैंT4 टेम्प्लेटअपने कोड से Html (या कोई भी) जेनरेट करने के लिए। यह देखो:http://msdn.microsoft.com/en-us/library/ee844259.aspx

स्रोत

Dan Herbert

Translate

यदि आप HTML डॉक्यूमेंट बनाना चाहते हैं, तो आप C # में XML डॉक्यूमेंट कैसे बनायेंगे, आप Microsoft के ओपन सोर्स लाइब्रेरी को आज़मा सकते हैं,Html चपलता पैक.

यह एक HtmlDocument ऑब्जेक्ट प्रदान करता है जिसमें बहुत समान API हैSystem.Xml.XmlDocumentकक्षा।

स्रोत

Jacob

Translate

आप वेब पृष्ठों के संदर्भ में अपने HTML को उत्पन्न करने के लिए ASP.NET का उपयोग कर सकते हैं।यहाँ एक लेख हैदिखाता है कि यह कैसे किया जा सकता है।

स्रोत

Sergey Shandar

Translate

आप कुछ तीसरे पक्ष के ओपन-सोर्स लाइब्रेरीज़ का उपयोग कर सकते हैं ताकि मजबूत टाइप किए गए वैरिफाइड (X) HTML उत्पन्न होंCityLizard फ्रेमवर्कया तीव्र डोम।

अपडेट करेंउदाहरण के लिए

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

स्रोत

Brendan Kowitz

Translate

यह एक सामान्य समाधान नहीं है, हालाँकि, यदि आपके विद्यार्थियों को ईमेल टेम्प्लेट रखना या बनाए रखना है तो System.Web में एक अंतर्निहित वर्ग हैMailDefinition। यह वर्ग HTML ईमेल बनाने के लिए ASP.NET सदस्यता नियंत्रण द्वारा उपयोग किया जाता है।

ऊपर बताई गई चीजों की तरह ही 'स्ट्रिंग को प्रतिस्थापित' करता है, लेकिन यह सब आपके लिए एक MailMessage में पैक करता है।

यहाँ 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;

स्रोत

Greg Gum

Translate

ASP.net MVC में रेजर की शुरुआत के साथ, C # में HTML लिखने का सबसे अच्छा तरीका रेजर इंजन के साथ है।

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

साँचा:

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

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

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

एक पूर्ण नमूने के लिए, देखेंयहाँ

स्रोत

Matias

Translate

यदि आप इसका बहुत अधिक उपयोग करते हैं, तो आप इसके रेंडर विधि और अन्य विशेषताओं के साथ अपनी खुद की कक्षाएं लिख सकते हैं, ताकि आप इसे बहुत उपयोग कर सकें और फिर HTMLWriter या xmlwriter का भी उपयोग कर सकें। इस तर्क का उपयोग asp.net पृष्ठों में किया जाता है, आप webControl से इनहेरिट कर सकते हैं और ओवरराइड कर सकते हैंरेंडर विधि, यदि आप सर्वर-साइड नियंत्रण विकसित कर रहे हैं, तो बहुत अच्छा है।
यहएक अच्छा उदाहरण हो सकता है।

सादर

स्रोत

Jeff Wilcox

Translate

यह वास्तव में निर्भर करता है कि आप क्या करने जा रहे हैं, और विशेष रूप से, आपको वास्तव में किस प्रकार का प्रदर्शन करने की आवश्यकता है।

मैंने दृढ़ता से टाइप किए गए HTML विकास (पूर्ण नियंत्रण मॉडल, एएसपी.नेट वेब कंट्रोल या इसके समान) के लिए सराहनीय समाधान देखे हैं, जो केवल एक परियोजना में अद्भुत जटिलता जोड़ते हैं। अन्य स्थितियों में, यह एकदम सही है।

C # दुनिया में वरीयता के क्रम में,

ASP.NET वेब नियंत्रण
ASP.NET आदिम और HTML नियंत्रण
XmlWriter और / या HtmlWriter
यदि HTML इंटरऑपरेबिलिटी के साथ सिल्वरलाइट विकास कर रहा है, तो कुछ दृढ़ता से टाइप करेंलिंक पाठ
StringBuilder और अन्य सुपर आदिम

स्रोत

Kaveh Shahbazian

Translate

मैंने इन वर्गों को लिखा, जिन्होंने मुझे अच्छी सेवा दी। यह सरल अभी तक व्यावहारिक है।

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

स्रोत

MMA

Translate

एचएसएचआरपी एक पुस्तकालय है जिसका उपयोग एचटीएमएल जैसी मार्कअप भाषा का आसानी से और तेजी से विश्लेषण करने के लिए किया जाता है। इंस्टॉल: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);

और उत्पादन:

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

स्रोत

howardlo

Translate

मैं एक ऐसी चीज़ की तलाश में था जो C # में डोम बनाने के लिए jquery जैसी दिखती थी (मुझे पार्स करने की आवश्यकता नहीं है)। दुर्भाग्य से एक हल्के समाधान खोजने में कोई भाग्य नहीं है इसलिए मैंने यह सरल वर्ग बनाया है जो System.Xml.Linq.XElement से विरासत में मिला है। मुख्य विशेषता यह है कि आप ऑपरेटर को श्रृंखलाबद्ध कर सकते हैं जैसे कि जावास्क्रिप्ट में jquery का उपयोग करते समय ताकि यह अधिक धाराप्रवाह हो। यह पूरी तरह से चित्रित नहीं है, लेकिन यह वही करता है जो मुझे चाहिए और यदि रुचि है तो मैं एक गिट शुरू कर सकता हूं।

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

नमूना:

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

उपरोक्त कोड से आउटपुट:

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

स्रोत

c# - HTML को string में लिखें

सभी उत्तर

Leave a Reply

लेखक के बारे में

इसी तरह की समस्याएं

Category