Ecrire html en C #
J'ai un code comme ça. Existe-t-il un moyen de faciliter l'écriture et la maintenance? Utiliser 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}", "");
}
-edit- je ne le savais pas alors mais je pourrais é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");
et cela fonctionnera, mais il faudra tout remplacer par ""
Vous ferez probablement mieux d'utiliser un HtmlTextWriter ou un XMLWriter qu'un simple StringWriter. Ils prendront soin de vous échapper et de vous assurer que le document est bien formé.
Cette page montre les bases de l'utilisation de la classe HtmlTextWriter, dont Gist est:
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();
Lorsque je traite ce problème dans d’autres langues, je privilégie une séparation du code et du HTML. Quelque chose comme:
1.) Créez un modèle HTML. utilisez les espaces réservés [varname] pour marquer le contenu remplacé/inséré.
2.) Remplissez les variables de votre modèle à partir d’un tableau ou d’une structure/mappage/dictionnaire
Write( FillTemplate(myHTMLTemplate, myVariables) ) # pseudo-code
Je sais que vous avez posé des questions sur C #, mais si vous souhaitez utiliser n’importe quel langage .Net, je vous recommande vivement Visual Basic pour ce problème précis. Visual Basic possède une fonctionnalité appelée XML Literals 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 code HTML simple avec des trous d'expression dans l'ancien style ASP et rend votre code très lisible. Malheureusement, cette fonctionnalité n'est pas en C #, mais vous pouvez écrire un seul module dans VB et l'ajouter en tant que 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'expression. L'indentation pour les trous d'expression est meilleure dans VS2010.
Utilisez une XDocument pour créer le DOM, puis écrivez-le en utilisant une XmlWriter. 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>
Vous pouvez utiliser des objets System.Xml.Linq. Ils ont été entièrement repensés à partir de l’ancien System.Xml jours, ce qui rendait vraiment fastidieuse la construction de XML à partir de rien.
Autre que le doctype, je suppose, vous pourriez 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"
)
);
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);
Vous pouvez utiliser T4 Templates pour générer du code HTML (ou autre) à partir de votre code . Voir ceci: http://msdn.Microsoft.com/en-us/library/ee844259.aspx
La méthode la plus simple consiste à utiliser un objet XmlWriter. Ceci peut être utilisé pour produire du code HTML valide et s’occupe de toutes les séquences d’échappement désagréables pour vous.
Vous pouvez utiliser ASP.NET pour générer votre code HTML en dehors du contexte des pages Web. Voici un article qui montre comment cela peut être fait.
Vous pouvez utiliser des bibliothèques de source ouverte tierces pour générer un code (X) HTML vérifié fortement typé, tel que CityLizard Framework ou Sharp DOM.
Update Par 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"]]
]
]
];
Si vous souhaitez créer un document HTML similaire à celui d'un document XML en C #, vous pouvez essayer la bibliothèque open source de Microsoft, le Html Agility Pack .
Il fournit un objet HtmlDocument qui possède une API très similaire à la classe System.Xml.XmlDocument .
Il ne s’agit toutefois pas d’une solution générique. Si votre objectif est d’avoir ou de gérer des modèles de courrier électronique, System.Web a une classe intégrée appelée MailDefinition . Cette classe est utilisée par les contrôles d’appartenance ASP.NET pour créer des courriels HTML.
Est-ce que le même genre de "chaîne remplace" les choses comme mentionné ci-dessus, mais tout est emballé 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;
Avec l'introduction de Razor dans ASP.net MVC, le meilleur moyen d'écrire HTML en C # est d'utiliser Razor Engine.
string templatePath = $@"{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 échantillon complet, voir ici
Vous pouvez écrire vos propres classes avec sa méthode de rendu, ainsi que d'autres attributs, pour éviter les dégâts 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 la méthode render , ce qui est très utile si vous développez des contrôles côté serveur.
Ceci pourrait être un bon exemple.
Cordialement
Cela dépend vraiment de ce que vous recherchez et du type de performance que vous devez réellement offrir.
J'ai vu des solutions admirables pour un développement HTML fortement typé (modèles de contrôle complets, qu'il s'agisse de contrôles Web ASP.NET ou similaire) qui ajoutent 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 développez Silverlight avec l’interopérabilité HTML, considérez quelque chose de fortement typé, tel que link text
- StringBuilder et autres super primitives
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;
}
}
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>