Create, load, edit and save HTML code using C#, create different environment configurations, set up a sandbox

README.md

Work with HTML Documents in C# using Aspose.HTML

This repository contains C# code examples referenced in the Aspose.HTML for .NET documentation. These gists demonstrate practical ways to load, read, create, modify, and save HTML documents programmatically using C# and the powerful Aspose.HTML for .NET API.

What’s Inside

The gists in this collection cover:

• Loading HTML documents from files, strings, streams, or web URLs.
• Loading EPUB and MHTML documents.
• Creating and manipulating HTML elements dynamically.
• Working with DOM, navigation, and content modification.
• Navigation and manipulation the DOM tree using W3C-compliant traversal interfaces to inspect and retrieve content from HTML documents.
• Setting custom user style sheets, font folders, message handlers, sandboxing, and other environment parameters to tailor document rendering and behavior.
• Saving HTML documents in different formats like HTML, MHTML, or Markdown.
• Saving documents along with all linked resources like CSS, fonts, and images using customizable saving options.

Each example is self-contained and ready to use.

Related Documentation

These samples support the tutorials in the Working with HTML Documents chapter of the official documentation.

Other Related Resources

• Free Support Forum – Aspose.HTML
• Blog – Aspose.HTML Product Family
• API Reference – Aspose.HTML for .NET
• NuGet Package – Aspose.HTML for .NET

How to Use

1. Install the latest Aspose.HTML for .NET via NuGet.
2. You can download a free trial of Aspose.HTML for .NET and use a temporary license for unrestricted access.
3. Explore the gists in this repository and copy the relevant code to your project.
4. Configure paths, settings, and inputs to suit your environment.

Requirements

• .NET Platforms: .NET 5.0, .NET Framework 4.6.1+, or .NET Core 2.0+
• Supported OS: Windows, Linux, macOS
• Aspose.HTML for .NET

Aspose.HTML for .NET – Working with HTML Documents

Aspose.HTML for .NET – Working with HTML Documents

Example-BlocksScriptExecution.cs

// How to disable scripts for HTML to PDF conversion using C#
// Learn more: https://docs.aspose.com/html/net/sandboxing/

// Create an instance of the Configuration class
using (Configuration configuration = new Configuration())
{
    // Mark "scripts" as an untrusted resource
    configuration.Security |= Sandbox.Scripts;

    // Initialize an HTML document with specified configuration
    using (HTMLDocument document = new HTMLDocument(Path.Combine(DataDir, "document-with-scripts.html"), configuration))
    {
        // Convert HTML to PDF
        Converter.ConvertHTML(document, new PdfSaveOptions(), Path.Combine(OutputDir, "document-sandbox.pdf"));
    }
}

Example-CreateDocumentFromScratch.cs

// Create HTML from scratch using C#
// Learn more: https://docs.aspose.com/html/net/creating-a-document/

// Prepare an output path for a document saving
string documentPath = Path.Combine(OutputDir, "create-new-document.html");

// Initialize an empty HTML Document
using (HTMLDocument document = new HTMLDocument())
{
    HTMLElement body = document.Body;

    // Create a heading element <h1> and set its text
    HTMLHeadingElement h1 = (HTMLHeadingElement)document.CreateElement("h1");
    Text texth1 = document.CreateTextNode("Create HTML file");

    // Create a paragraph element set its text
    HTMLParagraphElement p = (HTMLParagraphElement)document.CreateElement("p");                
    Text text = document.CreateTextNode("Learn how to create HTML file");

    // Attach the text to the h1 and paragraph
    h1.AppendChild(texth1);
    p.AppendChild(text);

    // Attach h1 and paragraph to the document body
    body.AppendChild(h1);
    body.AppendChild(p);

    // Save the document to a disk
    document.Save(documentPath);
}

Example-CreateEmptyHtmlDocument.cs

// Create an empty HTML document using C#
// Learn more: https://docs.aspose.com/html/net/creating-a-document/

// Prepare an output path for a document saving
string documentPath = Path.Combine(OutputDir, "create-empty-document.html");

// Initialize an empty HTML Document
using (HTMLDocument document = new HTMLDocument())
{
    // Work with the document

    // Save the document to a file
    document.Save(documentPath);
}

Example-CreateHtmlDocumentFromString.cs

// Create HTML from a string using C#
// Learn more: https://docs.aspose.com/html/net/creating-a-document/

// Prepare HTML code
string html_code = "<p>Hello, World!</p>";

// Initialize a document from the string variable
using (HTMLDocument document = new HTMLDocument(html_code, "."))
{
    // Save the document to a disk
    document.Save(Path.Combine(OutputDir, "create-from-string.html"));
}

Example-CreateHtmlDocumentUsingDomAndConvertToPdf.cs

// Create and add new HTML elements using C#
// Learn more: https://docs.aspose.com/html/net/edit-html-document/

// Create an instance of an HTML document
using (HTMLDocument document = new HTMLDocument())
{
    // Create a <style> element and assign the green color for all elements with class-name equals 'gr'.
    Element style = document.CreateElement("style");
    style.TextContent = ".gr { color: green }";

    // Find the document <head> element and append the <style> element to it
    Element head = document.GetElementsByTagName("head").First();
    head.AppendChild(style);

    // Create a paragraph element with class-name 'gr'.
    HTMLParagraphElement p = (HTMLParagraphElement)document.CreateElement("p");
    p.ClassName = "gr";

    // Create a text node
    Text text = document.CreateTextNode("Hello World!!");

    // Append the text node to the paragraph
    p.AppendChild(text);

    // Append the paragraph to the document <body> element
    document.Body.AppendChild(p);

    // Save the HTML document to a file 
    document.Save(Path.Combine(OutputDir, "using-dom.html"));

    // Create an instance of the PDF output device and render the document into this device
    using (PdfDevice device = new PdfDevice(Path.Combine(OutputDir, "using-dom.pdf")))
    {
        // Render HTML to PDF
        document.RenderTo(device);
    }
}

Example-CreateNewHtmlDocument.cs

// Create an HTML document using C#
// Learn more: https://docs.aspose.com/html/net/creating-a-document/

// Prepare an output path for a document saving
string documentPath = Path.Combine(OutputDir, "create-new-document.html");

// Initialize an empty HTML Document
using (HTMLDocument document = new HTMLDocument())
{
    // Create a text node and add it to the document
    Text text = document.CreateTextNode("Hello, World!");
    document.Body.AppendChild(text);

    // Save the document to a disk
    document.Save(documentPath);
}

Example-DisableImageLoading.cs

// Disable loading images in HTML with sandbox configuration using C#
// Learn more: https://docs.aspose.com/html/net/sandboxing/

// Prepare HTML code and save it to a file
string code = "<span style=\"background-image:url('https://docs.aspose.com/html/images/work/lioness.jpg')\">Hello, World!!</span> " +
              "<script>document.write('Have a nice day!');</script>";

File.WriteAllText(Path.Combine(OutputDir, "sandboxing.html"), code);

// Create an instance of Configuration
using (Configuration configuration = new Configuration())
{
    // Mark 'Images' as an untrusted resource
    configuration.Security |= Sandbox.Images;

    // Initialize an HTML document with specified configuration
    using (HTMLDocument document = new HTMLDocument(Path.Combine(OutputDir, "sandboxing.html"), configuration))
    {
        // Convert HTML to PDF
        Converter.ConvertHTML(document, new PdfSaveOptions(), Path.Combine(OutputDir, "sandboxing-out.pdf"));
    }
}

Example-EditDocumentTree.cs

// Edit HTML document using DOM Tree
// Learn more: https://docs.aspose.com/html/net/edit-html-document/

// Create an instance of an HTML document
using (HTMLDocument document = new HTMLDocument())
{
    HTMLElement body = document.Body;

    // Create a paragraph element
    HTMLParagraphElement p = (HTMLParagraphElement)document.CreateElement("p");

    // Set a custom attribute
    p.SetAttribute("id", "my-paragraph");

    // Create a text node
    Text text = document.CreateTextNode("my first paragraph");

    // Attach the text to the paragraph
    p.AppendChild(text);

    // Attach the paragraph to the document body
    body.AppendChild(p);

    // Save the HTML document to a file
    document.Save(Path.Combine(OutputDir, "edit-document-tree.html"));
}

Example-EditExternalCss.cs

// Edit HTML with external CSS using C#
// Learn more: https://docs.aspose.com/html/net/edit-css-in-html/

// Prepare content of a CSS file
string styleContent = ".flower1 { width:120px; height:40px; border-radius:20px; background:#4387be; margin-top:50px; } \r\n" +
                      ".flower2 { margin-left:0px; margin-top:-40px; background:#4387be; border-radius:20px; width:120px; height:40px; transform:rotate(60deg); } \r\n" +
                      ".flower3 { transform:rotate(-60deg); margin-left:0px; margin-top:-40px; width:120px; height:40px; border-radius:20px; background:#4387be; }\r\n" +
                      ".frame { margin-top:-50px; margin-left:310px; width:160px; height:50px; font-size:2em; font-family:Verdana; color:grey; }\r\n";

// Prepare a linked CSS file
File.WriteAllText("flower.css", styleContent);

// Create an instance of an HTML document with specified content
string htmlContent = "<link rel=\"stylesheet\" href=\"flower.css\" type=\"text/css\" /> \r\n" +
                     "<div style=\"margin-top: 80px; margin-left:250px; transform: scale(1.3);\" >\r\n" +
                     "<div class=\"flower1\" ></div>\r\n" +
                     "<div class=\"flower2\" ></div>\r\n" +
                     "<div class=\"flower3\" ></div></div>\r\n" +
                     "<div style = \"margin-top: -90px; margin-left:120px; transform:scale(1);\" >\r\n" +
                     "<div class=\"flower1\" style=\"background: #93cdea;\"></div>\r\n" +
                     "<div class=\"flower2\" style=\"background: #93cdea;\"></div>\r\n" +
                     "<div class=\"flower3\" style=\"background: #93cdea;\"></div></div>\r\n" +
                     "<div style =\"margin-top: -90px; margin-left:-80px; transform: scale(0.7);\" >\r\n" +
                     "<div class=\"flower1\" style=\"background: #d5effc;\"></div>\r\n" +
                     "<div class=\"flower2\" style=\"background: #d5effc;\"></div>\r\n" +
                     "<div class=\"flower3\" style=\"background: #d5effc;\"></div></div>\r\n" +
                     "<p class=\"frame\">External</p>\r\n" +
                     "<p class=\"frame\" style=\"letter-spacing:10px; font-size:2.5em \">  CSS </p>\r\n";

using (HTMLDocument document = new HTMLDocument(htmlContent, "."))
{
    // Save the HTML document to a file 
    document.Save(Path.Combine(OutputDir, "edit-external-css.html"));
}

Example-EditInlineCss.cs

// How to set inline CSS styles in an HTML element using C#
// Learn more: https://docs.aspose.com/html/net/edit-css-in-html/

// Create an instance of an HTML document with specified content
string content = "<p>InlineCSS </p>";
using (HTMLDocument document = new HTMLDocument(content, "."))
{
    // Find the paragraph element to set a style
    HTMLElement paragraph = (HTMLElement)document.GetElementsByTagName("p").First();

    // Set the style attribute
    paragraph.SetAttribute("style", "font-size:250%; font-family:verdana; color:#cd66aa");

    // Save the HTML document to a file 
    document.Save(Path.Combine(OutputDir, "edit-inline-css.html"));

    // Create an instance of PDF output device and render the document into this device
    using (PdfDevice device = new PdfDevice(Path.Combine(OutputDir, "edit-inline-css.pdf")))
    {
        // Render HTML to PDF
        document.RenderTo(device);
    }
}

Example-EditInternalCss.cs

// Edit HTML with internal CSS using C#
// Learn more: https://docs.aspose.com/html/net/edit-css-in-html/

// Create an instance of an HTML document with specified content
string content = "<div><p>Internal CSS</p><p>An internal CSS is used to define a style for a single HTML page</p></div>";
using (HTMLDocument document = new HTMLDocument(content, "."))
{
    Element style = document.CreateElement("style");
    style.TextContent = ".frame1 { margin-top:50px; margin-left:50px; padding:20px; width:360px; height:90px; background-color:#a52a2a; font-family:verdana; color:#FFF5EE;} \r\n" +
                        ".frame2 { margin-top:-90px; margin-left:160px; text-align:center; padding:20px; width:360px; height:100px; background-color:#ADD8E6;}";

    // Find the document header element and append the style element to the header
    Element head = document.GetElementsByTagName("head").First();
    head.AppendChild(style);

    // Find the first paragraph element to inspect the styles
    HTMLElement paragraph = (HTMLElement)document.GetElementsByTagName("p").First();
    paragraph.ClassName = "frame1";

    // Find the last paragraph element to inspect the styles
    HTMLElement lastParagraph = (HTMLElement)document.GetElementsByTagName("p").Last();
    lastParagraph.ClassName = "frame2";

    // Set a color to the first paragraph
    paragraph.Style.FontSize = "250%";
    paragraph.Style.TextAlign = "center";

    // Set a font-size to the last paragraph
    lastParagraph.Style.Color = "#434343";
    lastParagraph.Style.FontSize= "150%";
    lastParagraph.Style.FontFamily = "verdana";

    // Save the HTML document to a file 
    document.Save(Path.Combine(OutputDir, "edit-internal-css.html"));

    // Create the instance of the PDF output device and render the document into this device
    using (PdfDevice device = new PdfDevice(Path.Combine(OutputDir, "edit-internal-css.pdf")))
    {
        // Render HTML to PDF
        document.RenderTo(device);
    }
}

Example-LimitJavaScriptExecutionUsingRuntimeService.cs

// Limit JavaScript execution time for HTML rendering using C#
// Learn more: https://docs.aspose.com/html/net/environment-configuration/

// Prepare an HTML code and save it to a file
string code = "<h1>Runtime Service</h1>\r\n" +
              "<script> while(true) {} </script>\r\n" +
              "<p>The Runtime Service optimizes your system by helping it start apps and programs faster.</p>\r\n";

File.WriteAllText(Path.Combine(OutputDir, "runtime-service.html"), code);

// Create an instance of Configuration
using (Configuration configuration = new Configuration())
{
    // Limit JS execution time to 5 seconds
    IRuntimeService runtimeService = configuration.GetService<IRuntimeService>();
    runtimeService.JavaScriptTimeout = TimeSpan.FromSeconds(5);

    // Initialize an HTML document with specified configuration
    using (HTMLDocument document = new HTMLDocument(Path.Combine(OutputDir, "runtime-service.html"), configuration))
    {
        // Convert HTML to PNG
        Converter.ConvertHTML(document, new ImageSaveOptions(), Path.Combine(OutputDir, "runtime-service_out.png"));
    }
}

Example-LoadEditAndSaveHtmlDocument.cs

// How to load, edit, and save an HTML document in C#
// Learn more: https://docs.aspose.com/html/net/edit-html-document/

string inputPath = Path.Combine(DataDir, "html_file.html");
string outputPath = Path.Combine(OutputDir, "working-with-documents.html");

using (HTMLDocument document = new HTMLDocument(inputPath))
{
    Element title = document.QuerySelector("title");
    if (title != null)
    {
        title.TextContent = "Updated Aspose HTML test page";
    }

    Element heading = document.QuerySelector("h1");
    if (heading != null)
    {
        heading.TextContent = "Updated HTML document";
    }

    Element body = document.QuerySelector("body");
    if (body != null)
    {
        body.SetAttribute("style", "background-color: #f4f7fb; font-family: Arial, sans-serif; line-height: 1.5;");
        body.RemoveAttribute("bgcolor");
    }

    Element firstParagraph = document.QuerySelector("p");
    if (firstParagraph != null)
    {
        firstParagraph.TextContent = "This paragraph was updated through the HTML DOM API.";
    }

    Element image = document.QuerySelector("img");
    if (image != null)
    {
        image.SetAttribute("alt", "Portrait image used on the Aspose HTML test page");
    }

    document.Save(outputPath);
}

Example-LoadHtmlDocumentFromExistingFile.cs

// Load an HTML documment from a file using C#
// Learn more: https://docs.aspose.com/html/net/creating-a-document/

// Prepare a file path
string documentPath = Path.Combine(DataDir, "sprite.html");

// Initialize an HTML document from the file
using (HTMLDocument document = new HTMLDocument(documentPath))
{
    // Work with the document

    // Save the document to a disk
    document.Save(Path.Combine(OutputDir, "sprite_out.html"));
}

Example-LoadHtmlDocumentFromFile.cs

// Load HTML from a file using C#
// Learn more: https://docs.aspose.com/html/net/creating-a-document/

string htmlFile = Path.Combine(OutputDir, "load-from-file.html");

// Prepare a load-from-file.html document
File.WriteAllText(htmlFile, "Hello, World!");

// Load from the load-from-file.html 
using (HTMLDocument document = new HTMLDocument(htmlFile))
{
    // Write the document content to the output stream
    Console.WriteLine(document.DocumentElement.OuterHTML);
}

Example-LoadHtmlDocumentFromStream.cs

// Load HTML from a stream using C#
// Learn more: https://docs.aspose.com/html/net/creating-a-document/

// Create a memory stream object
using (MemoryStream mem = new MemoryStream())
using (StreamWriter sw = new StreamWriter(mem))
{
    // Write the HTML code into memory object
    sw.Write("<p>Hello, World! I love HTML!</p>");

    // It is important to set the position to the beginning, since HTMLDocument starts the reading exactly from the current position within the stream
    sw.Flush();
    mem.Seek(0, SeekOrigin.Begin);

    // Initialize a document from the string variable
    using (HTMLDocument document = new HTMLDocument(mem, "."))
    {
        // Save the document to disk
        document.Save(Path.Combine(OutputDir, "load-from-stream.html"));
    }
}

Example-LoadHtmlDocumentFromUrl.cs

// Load HTML from a URL using C#
// Learn more: https://docs.aspose.com/html/net/creating-a-document/

// Load a document from 'https://docs.aspose.com/html/files/document.html' web page
using (HTMLDocument document = new HTMLDocument("https://docs.aspose.com/html/files/document.html"))
{
    string html = document.DocumentElement.OuterHTML;

    // Write the document content to the output stream
    Console.WriteLine(html);
}

Example-LoadSvgDocumentFromString.cs

// Load SVG from a string using C#
// Learn more: https://docs.aspose.com/html/net/creating-a-document/

// Initialize an SVG document from a string object
using (SVGDocument document = new SVGDocument("<svg xmlns='http://www.w3.org/2000/svg'><circle cx='50' cy='50' r='40'/></svg>", "."))
{
    // Write the document content to the output stream
    Console.WriteLine(document.DocumentElement.OuterHTML);
}

Example-LogMessageHandlerClass.cs

// Custom message handler that records unsuccessful HTTP responses
// Learn more: https://docs.aspose.com/html/net/environment-configuration/
       
private class LogMessageHandler : MessageHandler
{
    private readonly List<string> errors = new List<string>();

    public List<string> ErrorMessages
    {
        get { return errors; }
    }

    public override void Invoke(INetworkOperationContext context)
    {
        int statusCode = (int)context.Response.StatusCode;

        // Treat any response outside the successful 2xx range as an error
        if (statusCode < 200 || statusCode >= 300)
        {
            errors.Add(string.Format(
                "Resource '{0}' returned HTTP status {1}.",
                context.Request.RequestUri,
                statusCode));
        }

        // Continue processing through the message handler chain
        Next(context);
    }
}

Example-MemoryResourceHandlerClass.cs

// In-memory resource handler that captures and stores HTML resources as streams
// Learn more: https://docs.aspose.com/html/net/save-html-with-resources/

internal class MemoryResourceHandler : ResourceHandler
{
    public List<Tuple<Stream, Resource>> Streams;

    public MemoryResourceHandler()
    {
        Streams = new List<Tuple<Stream, Resource>>();
    }

    public override void HandleResource(Resource resource, ResourceHandlingContext context)
    {
        MemoryStream outputStream = new MemoryStream();
        Streams.Add(Tuple.Create<Stream, Resource>(outputStream, resource));
        resource
            .WithOutputUrl(new Url(Path.GetFileName(resource.OriginalUrl.Pathname), "memory:///"))
            .Save(outputStream, context);
    }

    public void PrintInfo()
    {
        foreach (Tuple<Stream, Resource> stream in Streams)
            Console.WriteLine($"uri:{stream.Item2.OutputUrl}, length:{stream.Item1.Length}");
    }
}

Example-NetworkServiceLogging.cs

// Log network errors during HTML processing using custom message handler in C#
// Learn more: https://docs.aspose.com/html/net/environment-configuration/

// Prepare HTML code and save it to a file
string code = "<img src=\"https://docs.aspose.com/svg/net/drawing-basics/filters-and-gradients/park.jpg\" >\r\n" +
              "<img src=\"https://docs.aspose.com/html/net/missing1.jpg\" >\r\n" +
              "<img src=\"https://docs.aspose.com/html/net/missing2.jpg\" >\r\n";

File.WriteAllText(Path.Combine(OutputDir, "network-service.html"), code);

// Create an instance of Configuration
using (Configuration configuration = new Configuration())
{
    // Add the LogMessageHandler to the chain of existing message handlers
    INetworkService networkService = configuration.GetService<INetworkService>();

    LogMessageHandler logHandler = new LogMessageHandler();
    networkService.MessageHandlers.Add(logHandler);

    // Initialize an HTML document with specified configuration
    using (HTMLDocument document = new HTMLDocument(Path.Combine(OutputDir, "network-service.html"), configuration))
    {
        //Convert HTML to PNG
        Converter.ConvertHTML(document, new ImageSaveOptions(), Path.Combine(OutputDir, "network-service_out.png"));

        // Print the List of ErrorMessages
        foreach (string errorMessage in logHandler.ErrorMessages)
        {
            Console.WriteLine(errorMessage);
        }
    }
}

Example-RemoveOrReplaceElement.cs

// Remove or replace HTML elements in C#
// Learn more: https://docs.aspose.com/html/net/edit-html-document/

// Prepare paths for the source and updated HTML files
string inputPath = Path.Combine(OutputDir, "page-with-old-content.html");
string outputPath = Path.Combine(OutputDir, "page-with-updated-content.html");

// Create a source HTML document with old content
File.WriteAllText(inputPath,
    "<!DOCTYPE html>" +
    "<html>" +
    "<body>" +
    "<div id='notification'>This temporary notice should be removed.</div>" +
    "<section id='content'><p>Old content block.</p></section>" +
    "</body>" +
    "</html>");

// Load the source HTML document
using (HTMLDocument document = new HTMLDocument(inputPath))
{
    // Find and remove a temporary notification element
    Element notification = document.GetElementById("notification");
    if (notification != null)
    {
        notification.Remove();
    }

    // Replace the content section with new HTML markup
    Element content = document.GetElementById("content");
    if (content != null)
    {
        content.InnerHTML = "<h2>Updated Content</h2><p>This section was replaced with new HTML markup.</p>";
    }

    document.Save(outputPath);
}

Example-ReplaceAnExternalCssLink.cs

// Replace an external CSS stylesheet link in HTML using C#
// Learn more: https://docs.aspose.com/html/net/edit-css-in-html/

string inputPath = Path.Combine(OutputDir, "external-css-source.html");
string outputPath = Path.Combine(OutputDir, "external-css-updated.html");
string oldCssPath = Path.Combine(OutputDir, "old-theme.css");
string newCssPath = Path.Combine(OutputDir, "new-theme.css");

// Define old and new CSS content
string oldCss =
    "body { color: #555; background-color: #ffffff; }" +
    ".content { padding: 12px; border-left: 4px solid #999; }";
string newCss =
    "body { color: #1f2937; background-color: #f7fbff; }" +
    ".content { padding: 12px; border-left: 4px solid #2f80ed; font-weight: 700; }";

// Create linked CSS files
File.WriteAllText(oldCssPath, oldCss);
File.WriteAllText(newCssPath, newCss);

// Create a source HTML document linked to the old stylesheet
File.WriteAllText(inputPath,
    "<!DOCTYPE html>" +
    "<html>" +
    "<head>" +
    "<link rel='stylesheet' href='old-theme.css'>" +
    "</head>" +
    "<body>" +
    "<main class='content'>External CSS controls this content block.</main>" +
    "</body>" +
    "</html>");

// Load the source HTML document
using (HTMLDocument document = new HTMLDocument(inputPath))
{
    // Find the external stylesheet link and point it to the new CSS file
    Element stylesheet = document.QuerySelector("link[rel='stylesheet']");
    if (stylesheet != null)
    {
        stylesheet.SetAttribute("href", "new-theme.css");
    }

    File.WriteAllText(outputPath, document.DocumentElement.OuterHTML);
}

Example-SandboxScripts.cs

// Enable sandboxing to restrict script execution when loading HTML
// Learn more: https://docs.aspose.com/html/net/environment-configuration/

// Prepare HTML code and save it to a file
string code = "<span>Hello, World!!</span> " +
              "<script>document.write('Have a nice day!');</script>";

File.WriteAllText(Path.Combine(OutputDir, "sandboxing.html"), code);

// Create an instance of Configuration
using (Configuration configuration = new Configuration())
{
    // Mark 'scripts' as an untrusted resource
    configuration.Security |= Sandbox.Scripts;

    // Initialize an HTML document with specified configuration
    using (HTMLDocument document = new HTMLDocument(Path.Combine(OutputDir, "sandboxing.html"), configuration))
    {
        // Convert HTML to PDF
        Converter.ConvertHTML(document, new PdfSaveOptions(), Path.Combine(OutputDir, "sandboxing_out.pdf"));
    }
}

Example-SaveHtmlToFile.cs

// Save HTML to a file using C#
// Learn more: https://docs.aspose.com/html/net/save-html-document/

// Prepare an output path for a document saving
string documentPath = Path.Combine(OutputDir, "save-to-file.html");

// Initialize an empty HTML document
using (HTMLDocument document = new HTMLDocument())
{
    // Create a text element and add it to the document
    Text text = document.CreateTextNode("Hello, World!");
    document.Body.AppendChild(text);

    // Save the HTML document to the file on a disk
    document.Save(documentPath);
}

Example-SaveHtmlToMarkdown.cs

// Save HTML as Markdown using C#
// Learn more: https://docs.aspose.com/html/net/save-html-document/

// Prepare an output path for a document saving
string documentPath = Path.Combine(OutputDir, "save-html-to-markdown.md");

// Prepare HTML code
string html_code = "<H2>Hello, World!</H2>";

// Initialize a document from a string variable
using (HTMLDocument document = new HTMLDocument(html_code, "."))
{
    // Save the document as a Markdown file
    document.Save(documentPath, HTMLSaveFormat.Markdown);
}

Example-SaveHtmlToMemory.cs

// Save HTML with resources to memory streams using C#
// Learn more: https://docs.aspose.com/html/net/save-html-with-resources/

// Prepare a path to a source HTML file 
string inputPath = Path.Combine(DataDir, "with-resources.html");

// Load the HTML document 
using (HTMLDocument doc = new HTMLDocument(inputPath))
{
    // Create an instance of the MemoryResourceHandler class and save HTML to memory
    MemoryResourceHandler resourceHandler = new MemoryResourceHandler();
    doc.Save(resourceHandler);
    resourceHandler.PrintInfo();
}

Example-SaveHtmlToMHtml.cs

// Save HTML as MHTML using C#
// Learn more: https://docs.aspose.com/html/net/save-html-document/

// Prepare an output path for a document saving
string savePath = Path.Combine(OutputDir, "save-to-mhtml.mht");

// Prepare a simple HTML file with a linked document
File.WriteAllText("save-to-mhtml.html", "<p>Hello, World!</p>" +
                                        "<a href='linked-file.html'>linked file</a>");

// Prepare a simple linked HTML file
File.WriteAllText("linked-file.html", "<p>Hello, linked file!</p>");

// Load the "save-to-mhtml.html" into memory
using (HTMLDocument document = new HTMLDocument("save-to-mhtml.html"))
{
    // Save the document to MHTML format
    document.Save(savePath, HTMLSaveFormat.MHTML);
}

Example-SaveHtmlWithLinkedFile.cs

// Save HTML with a linked resources using C#
// Learn more: https://docs.aspose.com/html/net/save-html-with-resources/

// Prepare an output path for an HTML document 
string documentPath = Path.Combine(OutputDir, "save-with-linked-file.html");

// Prepare a simple HTML file with a linked document
File.WriteAllText(documentPath, "<p>Hello, World!</p>" +
                                "<a href='linked.html'>linked file</a>");

// Prepare a simple linked HTML file
File.WriteAllText(Path.Combine(OutputDir, "linked.html"), "<p>Hello, linked file!</p>");

// Load the "save-with-linked-file.html" into memory
using (HTMLDocument document = new HTMLDocument(documentPath))
{
    // Create a save options instance
    HTMLSaveOptions options = new HTMLSaveOptions();

    // The following line with value '0' cuts off all other linked HTML-files while saving this instance
    // If you remove this line or change value to the '1', the 'linked.html' file will be saved as well to the output folder
    options.ResourceHandlingOptions.MaxHandlingDepth = 1;

    // Save the document with the save options
    document.Save(Path.Combine(OutputDir, "save-with-linked-file_out.html"), options);
}

Example-SaveHtmlWithResourcesToStorage.cs

// Save HTML with resources to local storage using C#
// Learn more: https://docs.aspose.com/html/net/save-html-with-resources/

// Prepare a path to a source HTML file
string inputPath = Path.Combine(DataDir, "with-resources.html");

// Prepare a full path to an output directory 
string customOutDir = Path.Combine(Directory.GetCurrentDirectory(), "./../../../../tests-out/saving/");

// Load the HTML document from a file
using (HTMLDocument doc = new HTMLDocument(inputPath))
{
    // Save HTML with resources
    doc.Save(new FileSystemResourceHandler(customOutDir));
}

Example-SaveHtmlWithResourcesToZip.cs

// Save an HTML document with all linked resources into a ZIP archive using C#
// Learn more: https://docs.aspose.com/html/net/save-html-with-resources/

// Prepare a path to a source HTML file 
string inputPath = Path.Combine(DataDir, "with-resources.html");

string dir = Directory.GetCurrentDirectory();

// Prepare a full path to an output zip storage
string customArchivePath = Path.Combine(dir, "./../../../../tests-out/saving/archive.zip");

// Load the HTML document 
using (HTMLDocument doc = new HTMLDocument(inputPath))
{
    // Initialize an instance of the ZipResourceHandler class
    using (ZipResourceHandler resourceHandler = new ZipResourceHandler(customArchivePath))
    {
        // Save HTML with resources to a Zip archive
        doc.Save(resourceHandler);
    }
}

Example-SaveSvgDocument.cs

// Create and save SVG image using C#
// Learn more: https://docs.aspose.com/html/net/save-html-document/

// Prepare an output path for a document saving
string documentPath = Path.Combine(OutputDir, "create-and-save-svg.svg");

// Prepare SVG code
string code = @"
    <svg xmlns='http://www.w3.org/2000/svg' height='200' width='300'>
        <g fill='none' stroke-width= '10' stroke-dasharray='30 10'>
            <path stroke='red' d='M 25 40 l 215 0' />
            <path stroke='black' d='M 35 80 l 215 0' />
            <path stroke='blue' d='M 45 120 l 215 0' />
        </g>
    </svg>";

// Initialize an SVG instance from the content string
using (SVGDocument document = new SVGDocument(code, "."))
{
    // Save the SVG file to a disk
    document.Save(documentPath);
}

Example-SetUserAgentCharset.cs

// Set character encoding and custom styles for HTML to PDF conversion in C#
// Learn more: https://docs.aspose.com/html/net/environment-configuration/

// Prepare HTML code and save it to a file
string code = "<h1>Character Set</h1>\r\n" +
              "<p>The <b>CharSet</b> property sets the primary character-set for a document.</p>\r\n";

File.WriteAllText(Path.Combine(OutputDir, "user-agent-charset.html"), code);

// Create an instance of Configuration
using (Configuration configuration = new Configuration())
{
    // Get the IUserAgentService
    IUserAgentService userAgentService = configuration.GetService<IUserAgentService>();

    // Set the custom style parameters for the <h1> and <p> elements
    userAgentService.UserStyleSheet = "h1 { color:salmon; }\r\n" +
                                      "p { background-color:#f0f0f0; color:DarkCyan; font-size:1.2em; }\r\n";

    // Set ISO-8859-1 encoding to parse the document
    userAgentService.CharSet = "ISO-8859-1";

    // Initialize the HTML document with specified configuration
    using (HTMLDocument document = new HTMLDocument(Path.Combine(OutputDir, "user-agent-charset.html"), configuration))
    {
        // Convert HTML to PDF
        Converter.ConvertHTML(document, new PdfSaveOptions(), Path.Combine(OutputDir, "user-agent-charset_out.pdf"));
    }
}

Example-SetUserAgentFontSettings.cs

// Set font folder for HTML to PDF conversion using C#
// Learn more: https://docs.aspose.com/html/net/environment-configuration/

// Prepare HTML code and save it to a file
string code = "<h1>FontsSettings property</h1>\r\n" +
              "<p>The FontsSettings property is used for configuration of fonts handling.</p>\r\n";

File.WriteAllText(Path.Combine(OutputDir, "user-agent-fontsetting.html"), code);

// Create an instance of Configuration
using (Configuration configuration = new Configuration())
{
    // Get the IUserAgentService
    IUserAgentService userAgentService = configuration.GetService<IUserAgentService>();

    // Set the custom style parameters for the <h1> and <p> elements
    userAgentService.UserStyleSheet = "h1 { color:#a52a2a; }\r\n" +
                                      "p { color:grey; }\r\n";

    // Set a custom font folder path
    userAgentService.FontsSettings.SetFontsLookupFolder(Path.Combine(DataDir + "fonts"));

    // Initialize the HTML document with specified configuration
    using (HTMLDocument document = new HTMLDocument(Path.Combine(OutputDir, "user-agent-fontsetting.html"), configuration))
    {
        // Convert HTML to PDF
        Converter.ConvertHTML(document, new PdfSaveOptions(), Path.Combine(OutputDir, "user-agent-fontsetting_out.pdf"));
    }
}

Example-UpdateAnExistingHtmlDocument.cs

// Edit an existing HTML document in C# using DOM methods
// Learn more: https://docs.aspose.com/html/net/edit-html-document/

// Prepare paths for the source and updated HTML files
string inputPath = Path.Combine(OutputDir, "existing-document.html");
string outputPath = Path.Combine(OutputDir, "updated-document.html");

// Create a source HTML document
File.WriteAllText(inputPath,
    "<!DOCTYPE html>" +
    "<html>" +
    "<body>" +
    "<h1 id='page-title'>Original Title</h1>" +
    "<p>Download the source file from the old link.</p>" +
    "<a class='download-link' href='old-file.html'>Old download link</a>" +
    "</body>" +
    "</html>");

// Load the source HTML document
using (HTMLDocument document = new HTMLDocument(inputPath))
{
    // Find a heading by id and update its text
    Element heading = document.GetElementById("page-title");
    if (heading != null)
    {
        heading.TextContent = "Updated HTML Document";
    }

    // Find a link by CSS selector and update its text and attributes
    Element downloadLink = document.QuerySelector("a.download-link");
    if (downloadLink != null)
    {
        downloadLink.TextContent = "Download updated file";
        downloadLink.SetAttribute("href", "updated-file.html");
        downloadLink.SetAttribute("title", "Download the updated HTML file");
    }

    document.Save(outputPath);
}

Example-UpdateInlineCssInExistingHtmlDocument.cs

// Edit inline CSS styles in an existing HTML document using C#
// Learn more: https://docs.aspose.com/html/net/edit-css-in-html/

// Prepare paths for the source and updated HTML files
string inputPath = Path.Combine(OutputDir, "inline-style-source.html");
string outputPath = Path.Combine(OutputDir, "inline-style-updated.html");

// Create a source HTML document with an inline style
File.WriteAllText(inputPath,
    "<!DOCTYPE html>" +
    "<html>" +
    "<body>" +
    "<p id='status' style='font-size: 20px;'>Processing completed with warnings.</p>" +
    "</body>" +
    "</html>");

// Load the source HTML document
using (HTMLDocument document = new HTMLDocument(inputPath))
{
    // Find the styled element by CSS selector
    Element status = document.QuerySelector("#status");
    if (status != null)
    {
        // Append new CSS declarations to the existing inline style
        string currentStyle = status.GetAttribute("style");
        string updatedStyle = currentStyle + " color: #b00020; font-weight: 700; background-color: #fff3f3;";

        status.SetAttribute("style", updatedStyle);
    }

    document.Save(outputPath);
}

Example-UseExternalCss.cs

// How to use an external CSS file in HTML using Aspose.HTML for .NET
// Learn more: https://docs.aspose.com/html/net/edit-css-in-html/

// Create an instance of HTML document with specified content
string htmlContent = "<link rel=\"stylesheet\" href=\"https://docs.aspose.com/html/files/external.css\" type=\"text/css\" />\r\n" +
                     "<div class=\"rect1\" ></div>\r\n" +
                     "<div class=\"rect2\" ></div>\r\n" +
                     "<div class=\"frame\">\r\n" +
                     "<p style=\"font-size:2.5em; color:#ae4566;\"> External CSS </p>\r\n" +
                     "<p class=\"rect3\"> An external CSS can be created once and applied to multiple web pages</p></div>\r\n";

using (HTMLDocument document = new HTMLDocument(htmlContent, "."))
{
    // Save the HTML document to a file 
    document.Save(Path.Combine(OutputDir, "external-css.html"));

    // Create the instance of the PDF output device and render the document into this device
    using (PdfDevice device = new PdfDevice(Path.Combine(OutputDir, "external-css.pdf")))
    {
        // Render HTML to PDF
        document.RenderTo(device);
    }
}

Example-UserAgentCustomStyles.cs

// Apply custom CSS via user agent service during HTML processing in C#
// Learn more: https://docs.aspose.com/html/net/environment-configuration/

// Prepare HTML code and save it to a file
string code = "<h1>User Agent Service </h1>\r\n" +
              "<p>The User Agent Service allows you to specify a custom user stylesheet, a primary character set for the document, language and fonts settings.</p>\r\n";

File.WriteAllText(Path.Combine(OutputDir, "user-agent-stylesheet.html"), code);

// Create an instance of Configuration
using (Configuration configuration = new Configuration())
{
    // Get the IUserAgentService
    IUserAgentService userAgentService = configuration.GetService<IUserAgentService>();

    // Set the custom style parameters for the <h1> and <p> elements
    userAgentService.UserStyleSheet = "h1 { color:#a52a2a;; font-size:2em;}\r\n" +
                                      "p { background-color:GhostWhite; color:SlateGrey; font-size:1.2em; }\r\n";

    // Initialize the HTML document with specified configuration
    using (HTMLDocument document = new HTMLDocument(Path.Combine(OutputDir, "user-agent-stylesheet.html"), configuration))
    {
        // Convert HTML to PDF
        Converter.ConvertHTML(document, new PdfSaveOptions(), Path.Combine(OutputDir, "user-agent-stylesheet_out.pdf"));
    }
}

Example-UsingAsynchronousOperations.cs

// Load HTML asynchronously using C#
// Learn more: https://docs.aspose.com/html/net/creating-a-document/

// Load HTML using Navigate() and wait for the complete ready state
using (AutoResetEvent resetEvent = new AutoResetEvent(false))
using (HTMLDocument document = new HTMLDocument())
{
    string outerHTML = string.Empty;

    // ReadyStateChange can be raised several times during loading
    document.OnReadyStateChange += (sender, @event) =>
    {
        if (document.ReadyState == "complete")
        {
            // Capture the loaded markup before notifying the waiting thread
            outerHTML = document.DocumentElement.OuterHTML;
            resetEvent.Set();
        }
    };

    // Start event-based document loading
    document.Navigate("https://docs.aspose.com/html/files/document.html");

    // Use a finite timeout to avoid waiting indefinitely
    if (!resetEvent.WaitOne(TimeSpan.FromSeconds(10)))
    {
        throw new TimeoutException(
            "The HTML document did not load within 10 seconds.");
    }

    // Access the markup only after the document has finished loading
    Console.WriteLine("outerHTML = {0}", outerHTML);
}

Example-UsingAsynchronousOperationsOnLoad.cs

// Handle an HTML document load using C#
// Learn more: https://docs.aspose.com/html/net/creating-a-document/

// Load HTML and handle completion through the OnLoad event
using (AutoResetEvent resetEvent = new AutoResetEvent(false))
using (HTMLDocument document = new HTMLDocument())
{
    string outerHTML = string.Empty;

    // OnLoad is raised when document loading is complete
    document.OnLoad += (sender, @event) =>
    {
        // Capture the loaded markup before releasing the waiting thread
        outerHTML = document.DocumentElement.OuterHTML;
        resetEvent.Set();
    };

    // Start event-based document loading
    document.Navigate("https://docs.aspose.com/html/files/document.html");

    // Stop waiting if loading does not complete within the selected timeout
    if (!resetEvent.WaitOne(TimeSpan.FromSeconds(10)))
    {
        throw new TimeoutException(
            "The HTML document did not load within 10 seconds.");
    }

    // Process the document only after receiving the load event
    Console.WriteLine("outerHTML = {0}", outerHTML);
}

Example-UsingInnerHTMLOuterHTML.cs

// Edit HTML body content and get modified document as string
// Learn more: https://docs.aspose.com/html/net/edit-html-document/

// Create an instance of an HTML document
using (HTMLDocument document = new HTMLDocument())
{
    // Write the content of the HTML document into the console output
    Console.WriteLine(document.DocumentElement.OuterHTML); // output: <html><head></head><body></body></html>

    // Set the content of the body element
    document.Body.InnerHTML = "<p>HTML is the standard markup language for Web pages.</p>";

    // Set an html variable for the document content viewing
    string html = document.DocumentElement.OuterHTML;

    // Write the content of the HTML document into the console output
    Console.WriteLine(html); // output: <html><head></head><body><p>HTML is the standard markup language for Web pages.</p></body></html>
}

Example-UsingOuterHTML.cs

// Read and output full HTML content from a loaded document in C#
// Learn more: https://docs.aspose.com/html/net/edit-html-document/

string documentPath = Path.Combine(DataDir, "document.html");

// Create an instance of an HTML document
using (HTMLDocument document = new HTMLDocument(documentPath))
{
    // Set an html variable for the document 
    string html = document.DocumentElement.OuterHTML;

    Console.WriteLine(html);
}

Example-ZipResourceHandlerClass.cs

// Custom resource handler to save HTML with resources into a ZIP archive
// Learn more: https://docs.aspose.com/html/net/save-html-with-resources/

internal class ZipResourceHandler : ResourceHandler, IDisposable
{
    private FileStream zipStream;
    private ZipArchive archive;
    private int streamsCounter;
    private bool initialized;

    public ZipResourceHandler(string name)
    {
        DisposeArchive();
        zipStream = new FileStream(name, FileMode.Create);
        archive = new ZipArchive(zipStream, ZipArchiveMode.Update);
        initialized = false;
    }

    public override void HandleResource(Resource resource, ResourceHandlingContext context)
    {
        string zipUri = (streamsCounter++ == 0
            ? Path.GetFileName(resource.OriginalUrl.Href)
            : Path.Combine(Path.GetFileName(Path.GetDirectoryName(resource.OriginalUrl.Href)),
                Path.GetFileName(resource.OriginalUrl.Href)));
        string samplePrefix = String.Empty;
        if (initialized)
            samplePrefix = "my_";
        else
            initialized = true;

        using (Stream newStream = archive.CreateEntry(samplePrefix + zipUri).Open())
        {
            resource.WithOutputUrl(new Url("file:///" + samplePrefix + zipUri)).Save(newStream, context);
        }
    }

    private void DisposeArchive()
    {
        if (archive != null)
        {
            archive.Dispose();
            archive = null;
        }

        if (zipStream != null)
        {
            zipStream.Dispose();
            zipStream = null;
        }

        streamsCounter = 0;
    }

    public void Dispose()
    {
        DisposeArchive();
    }
}