diff --git a/web-accessibility/access_validationresult_errors_collection_count_total_accessibility_errors_found_document.cs b/web-accessibility/access_validationresult_errors_collection_count_total_accessibility_errors_found_document.cs
new file mode 100644
index 0000000..9303df4
--- /dev/null
+++ b/web-accessibility/access_validationresult_errors_collection_count_total_accessibility_errors_found_document.cs
@@ -0,0 +1,65 @@
+// Access ValidationResult.Errors collection to count total accessibility errors found in the document.
+
+using System;
+using System.IO;
+using System.Text;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare a simple HTML file for validation
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src='image.jpg'></body></html>";
+            string inputFilePath = "sample.html";
+            File.WriteAllText(inputFilePath, htmlContent, Encoding.UTF8);
+
+            // Initialize WebAccessibility and validator
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load the HTML document
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputFilePath))
+            {
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                    {
+                        if (!detail.Success)
+                        {
+                            Console.WriteLine(detail.Rule.Code + " - " + detail.Rule.Description);
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in detail.Errors)
+                            {
+                                Aspose.Html.Accessibility.IError error = techResult.Error;
+                                Console.WriteLine("Error: " + error.ErrorMessage);
+                                if (error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)error.Target.Item;
+                                    Console.WriteLine("Element: " + element.OuterHTML);
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Document passed accessibility validation successfully.");
+                }
+            }
+
+            // Clean up the temporary file
+            if (File.Exists(inputFilePath))
+            {
+                File.Delete(inputFilePath);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("An error occurred: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/access_validationresult_warnings_collection_count_total_accessibility_warnings_html_page.cs b/web-accessibility/access_validationresult_warnings_collection_count_total_accessibility_warnings_html_page.cs
new file mode 100644
index 0000000..7c1a751
--- /dev/null
+++ b/web-accessibility/access_validationresult_warnings_collection_count_total_accessibility_warnings_html_page.cs
@@ -0,0 +1,48 @@
+// Access ValidationResult.Warnings collection to count total accessibility warnings reported for the HTML page.
+
+using System;
+using System.IO;
+using System.Collections;
+using System.Reflection;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src='image.jpg' alt=''></body></html>";
+            string inputPath = "sample.html";
+            File.WriteAllText(inputPath, htmlContent);
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+                Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                // Count warnings using reflection (property may not exist in this version)
+                int warningCount = 0;
+                PropertyInfo warningsProp = validationResult.GetType().GetProperty("Warnings");
+                if (warningsProp != null)
+                {
+                    IEnumerable warnings = warningsProp.GetValue(validationResult) as IEnumerable;
+                    if (warnings != null)
+                    {
+                        foreach (var _ in warnings)
+                        {
+                            warningCount++;
+                        }
+                    }
+                }
+
+                Console.WriteLine($"Total accessibility warnings: {warningCount}");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/add_missing_track_element_with_kind_captions_and_src_to_video_programmatically.cs b/web-accessibility/add_missing_track_element_with_kind_captions_and_src_to_video_programmatically.cs
new file mode 100644
index 0000000..d9c9405
--- /dev/null
+++ b/web-accessibility/add_missing_track_element_with_kind_captions_and_src_to_video_programmatically.cs
@@ -0,0 +1,135 @@
+// Add a missing <track> element with kind="captions" and appropriate src attribute to a video element programmatically.
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+using Aspose.Html.IO;
+
+class MemoryStreamProvider : Aspose.Html.IO.ICreateStreamProvider, IDisposable
+{
+    private readonly List<MemoryStream> _streams = new List<MemoryStream>();
+
+    public IReadOnlyList<MemoryStream> Streams => _streams.AsReadOnly();
+
+    public Stream GetStream(string name, string extension)
+    {
+        var ms = new MemoryStream();
+        _streams.Add(ms);
+        return ms;
+    }
+
+    public Stream GetStream(string name, string extension, int page)
+    {
+        var ms = new MemoryStream();
+        _streams.Add(ms);
+        return ms;
+    }
+
+    public void ReleaseStream(Stream stream)
+    {
+        // No action needed; streams are kept for later reading.
+    }
+
+    public void Dispose()
+    {
+        foreach (var ms in _streams)
+        {
+            ms.Dispose();
+        }
+        _streams.Clear();
+    }
+}
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare directories
+            string outputDir = Path.Combine(Directory.GetCurrentDirectory(), "AsposeHtmlOutput");
+            Directory.CreateDirectory(outputDir);
+
+            // Create a minimal sample HTML file
+            string inputHtmlPath = Path.Combine(outputDir, "sample.html");
+            string htmlContent = @"
+<!DOCTYPE html>
+<html>
+<head><title>Sample</title></head>
+<body>
+<p>First paragraph.</p>
+<p>Second paragraph.</p>
+<img src='https://example.com/image.png'>
+</body>
+</html>";
+            File.WriteAllText(inputHtmlPath, htmlContent);
+
+            // Load the document
+            var document = new Aspose.Html.HTMLDocument(inputHtmlPath);
+
+            // 1. Ensure all images have alt attributes
+            var images = document.GetElementsByTagName("img");
+            foreach (Aspose.Html.Dom.Element node in images)
+            {
+                var img = node as Aspose.Html.HTMLImageElement;
+                if (img != null)
+                {
+                    string alt = img.GetAttribute("alt");
+                    if (string.IsNullOrWhiteSpace(alt))
+                    {
+                        string autoAlt = "Auto-generated alt text";
+                        img.SetAttribute("alt", autoAlt);
+                    }
+                }
+            }
+
+            // 2. Insert a new image before the second paragraph
+            var paragraphs = document.GetElementsByTagName("p");
+            if (paragraphs.Length >= 2)
+            {
+                var newImg = (Aspose.Html.HTMLImageElement)document.CreateElement("img");
+                newImg.SetAttribute("src", "https://example.com/inserted.png");
+                newImg.SetAttribute("alt", "Inserted image");
+                Aspose.Html.Dom.Element secondParagraph = (Aspose.Html.Dom.Element)paragraphs[1];
+                secondParagraph.ParentNode.InsertBefore(newImg, secondParagraph.NextSibling);
+            }
+
+            // 3. Add a watermark div (DOM overlay)
+            var div = document.CreateElement("div");
+            div.SetAttribute("style", "position:absolute; top:10px; left:10px; font-size:24px; color:red; background:transparent;");
+            div.TextContent = "Watermark";
+            document.Body.AppendChild(div);
+
+            // Save the modified HTML
+            string modifiedHtmlPath = Path.Combine(outputDir, "modified.html");
+            document.Save(modifiedHtmlPath);
+
+            // 4. Convert the document to JPEG using a custom stream provider
+            var imageOptions = new Aspose.Html.Saving.ImageSaveOptions(Aspose.Html.Rendering.Image.ImageFormat.Jpeg);
+            using (var provider = new MemoryStreamProvider())
+            {
+                Aspose.Html.Converters.Converter.ConvertHTML(document, imageOptions, provider);
+
+                if (provider.Streams.Count > 0)
+                {
+                    var memory = provider.Streams[0];
+                    memory.Seek(0, SeekOrigin.Begin);
+                    string jpegPath = Path.Combine(outputDir, "output.jpg");
+                    using (var fs = File.Create(jpegPath))
+                    {
+                        memory.CopyTo(fs);
+                    }
+                }
+            }
+
+            Console.WriteLine("Processing completed successfully.");
+            Console.WriteLine($"Modified HTML saved to: {modifiedHtmlPath}");
+            Console.WriteLine($"JPEG image saved to: {Path.Combine(outputDir, "output.jpg")}");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("An error occurred:");
+            Console.WriteLine(ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/apply_cancellation_token_to_validation_process_for_graceful_termination_during_long_batch_runs.cs b/web-accessibility/apply_cancellation_token_to_validation_process_for_graceful_termination_during_long_batch_runs.cs
new file mode 100644
index 0000000..f8909da
--- /dev/null
+++ b/web-accessibility/apply_cancellation_token_to_validation_process_for_graceful_termination_during_long_batch_runs.cs
@@ -0,0 +1,108 @@
+// Apply a cancellation token to the validation process to allow graceful termination during long batch runs.
+
+using System;
+using System.IO;
+using System.Threading;
+using System.Collections.Generic;
+using System.Net;
+using Aspose.Html;
+using Aspose.Html.Net;
+using Aspose.Html.Services;
+using Aspose.Html.Saving;
+using Aspose.Html.Converters;
+
+class Handler : Aspose.Html.Net.MessageHandler
+{
+    public override void Invoke(Aspose.Html.Net.INetworkOperationContext context)
+    {
+        Next(context);
+        if (context.Response.StatusCode == HttpStatusCode.InternalServerError)
+            return;
+    }
+}
+
+class AuthHandler : Aspose.Html.Net.MessageHandler
+{
+    private const string AuthHeader = "Authorization";
+
+    public override void Invoke(Aspose.Html.Net.INetworkOperationContext context)
+    {
+        if (string.IsNullOrEmpty(context.Request.Headers[AuthHeader]))
+        {
+            context.Response.StatusCode = HttpStatusCode.Unauthorized;
+            return;
+        }
+        Next(context);
+    }
+}
+
+class LogHandler : Aspose.Html.Net.MessageHandler
+{
+    private readonly List<string> _logs = new List<string>();
+
+    public override void Invoke(Aspose.Html.Net.INetworkOperationContext context)
+    {
+        Next(context);
+        _logs.Add("URL: " + context.Request.RequestUri + " | Status: " + context.Response.StatusCode);
+    }
+
+    public IReadOnlyList<string> Logs => _logs;
+}
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            string inputFolder = "input";
+            string outputFolder = "output";
+
+            Directory.CreateDirectory(inputFolder);
+            Directory.CreateDirectory(outputFolder);
+
+            string sampleHtmlPath = Path.Combine(inputFolder, "sample.html");
+            if (!File.Exists(sampleHtmlPath))
+            {
+                File.WriteAllText(sampleHtmlPath, "<!DOCTYPE html><html><body><h1>Sample</h1></body></html>");
+            }
+
+            // Configure Aspose.Html with custom network handlers
+            Aspose.Html.Configuration configuration = new Aspose.Html.Configuration();
+            INetworkService network = configuration.GetService<INetworkService>();
+            network.MessageHandlers.Add(new Handler());
+            network.MessageHandlers.Add(new AuthHandler());
+            network.MessageHandlers.Add(new LogHandler());
+
+            var processedFiles = new HashSet<string>();
+
+            // Bounded polling loop (max 5 iterations)
+            for (int iteration = 0; iteration < 5; iteration++)
+            {
+                string[] htmlFiles = Directory.GetFiles(inputFolder, "*.html");
+                foreach (string htmlPath in htmlFiles)
+                {
+                    if (processedFiles.Contains(htmlPath))
+                        continue;
+
+                    using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlPath, configuration))
+                    {
+                        string outputPdfPath = Path.Combine(outputFolder,
+                            Path.GetFileNameWithoutExtension(htmlPath) + ".pdf");
+
+                        PdfSaveOptions pdfOptions = new PdfSaveOptions();
+                        Aspose.Html.Converters.Converter.ConvertHTML(document, pdfOptions, outputPdfPath);
+                    }
+
+                    processedFiles.Add(htmlPath);
+                }
+
+                Thread.Sleep(200);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/call_validationresult_savetostring_obtain_formatted_string_errors_warnings.cs b/web-accessibility/call_validationresult_savetostring_obtain_formatted_string_errors_warnings.cs
new file mode 100644
index 0000000..66548c1
--- /dev/null
+++ b/web-accessibility/call_validationresult_savetostring_obtain_formatted_string_errors_warnings.cs
@@ -0,0 +1,58 @@
+// Call ValidationResult.SaveToString to obtain a formatted string of errors and warnings.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src='image.png'></body></html>";
+            string tempFile = Path.Combine(Path.GetTempPath(), "sample.html");
+            File.WriteAllText(tempFile, htmlContent);
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(tempFile))
+            {
+                Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+                Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                    {
+                        if (!detail.Success)
+                        {
+                            Console.WriteLine(detail.Rule.Code + ": " + detail.Rule.Description);
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in detail.Errors)
+                            {
+                                Aspose.Html.Accessibility.IError error = techResult.Error;
+                                Console.WriteLine("Error: " + error.ErrorMessage);
+                                if (error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)error.Target.Item;
+                                    Console.WriteLine("Element HTML: " + element.OuterHTML);
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+            }
+
+            if (File.Exists(tempFile))
+            {
+                File.Delete(tempFile);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("An error occurred: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/check_missing_track_elements_kind_captions_in_video_tags_using_validation_report.cs b/web-accessibility/check_missing_track_elements_kind_captions_in_video_tags_using_validation_report.cs
new file mode 100644
index 0000000..9377239
--- /dev/null
+++ b/web-accessibility/check_missing_track_elements_kind_captions_in_video_tags_using_validation_report.cs
@@ -0,0 +1,55 @@
+// Check for missing <track> elements with kind="captions" in video tags using the validation report.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML containing an image without an alt attribute (accessibility issue)
+            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><img src='image.png'></body></html>";
+
+            // Load HTML content into a document (base URL can be empty for this example)
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, ""))
+            {
+                // Initialize WebAccessibility and create a validator that checks all rules
+                Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+                Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    // Retrieve the attribute value (e.g., "alt") if present
+                                    string attributeValue = element.GetAttribute("alt");
+                                    Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue ?? "(null)"}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/combine_validation_findings_with_seo_metrics_to_identify_pages_with_accessibility_and_ranking_issues.cs b/web-accessibility/combine_validation_findings_with_seo_metrics_to_identify_pages_with_accessibility_and_ranking_issues.cs
new file mode 100644
index 0000000..f163736
--- /dev/null
+++ b/web-accessibility/combine_validation_findings_with_seo_metrics_to_identify_pages_with_accessibility_and_ranking_issues.cs
@@ -0,0 +1,79 @@
+// Combine validation findings with SEO metrics to identify pages with both accessibility and ranking issues.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Create a minimal sample HTML file
+            string samplePath = Path.Combine(Directory.GetCurrentDirectory(), "sample.html");
+            if (!File.Exists(samplePath))
+            {
+                File.WriteAllText(samplePath,
+                    "<!DOCTYPE html><html><head><title>Sample</title></head>" +
+                    "<body><img src='image.png' alt='Sample image'></body></html>");
+            }
+
+            // List of URLs (using the local file path for simplicity)
+            List<string> urls = new List<string> { samplePath, samplePath };
+
+            // Output directory for validation results
+            string outputDir = Path.Combine(Directory.GetCurrentDirectory(), "ValidationResults");
+            Directory.CreateDirectory(outputDir);
+
+            // Initialize WebAccessibility and a validator that checks all rules
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator =
+                webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            int index = 1;
+            foreach (string url in urls)
+            {
+                using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(url))
+                {
+                    Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                    // Save the validation result as XML
+                    string outputPath = Path.Combine(outputDir, $"validation_result_{index}.xml");
+                    File.WriteAllText(outputPath, validationResult.ToString());
+
+                    // Output detailed errors to the console
+                    if (!validationResult.Success)
+                    {
+                        foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                        {
+                            if (!ruleResult.Success)
+                            {
+                                foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                                {
+                                    Aspose.Html.Accessibility.IError error = techResult.Error;
+                                    if (error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                    {
+                                        Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)error.Target.Item;
+                                        string tagName = element.TagName;
+                                        string altValue = element.GetAttribute("alt");
+                                        Console.WriteLine($"Tag: {tagName}, Attribute (alt): {altValue}, Message: {error.ErrorMessage}");
+                                    }
+                                    else
+                                    {
+                                        Console.WriteLine(error.ErrorMessage);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                index++;
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/compare_two_validationresult_objects_detect_regressions_after_modifying_html_content_same_project.cs b/web-accessibility/compare_two_validationresult_objects_detect_regressions_after_modifying_html_content_same_project.cs
new file mode 100644
index 0000000..0dbbbf3
--- /dev/null
+++ b/web-accessibility/compare_two_validationresult_objects_detect_regressions_after_modifying_html_content_same_project.cs
@@ -0,0 +1,57 @@
+// Compare two ValidationResult objects to detect regressions after modifying HTML content in the same project.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare sample HTML file
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Sample</h1><img src='image.png'></body></html>";
+            string tempFile = Path.Combine(Path.GetTempPath(), "sample.html");
+            File.WriteAllText(tempFile, htmlContent);
+
+            // Initialize accessibility validator
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            var document = new Aspose.Html.HTMLDocument(tempFile);
+            var validationResult = validator.Validate(document);
+
+            if (!validationResult.Success)
+            {
+                foreach (var ruleResult in validationResult.Details)
+                {
+                    if (!ruleResult.Success)
+                    {
+                        Console.WriteLine($"{ruleResult.Rule.Code}: {ruleResult.Rule.Description}");
+                        foreach (var techResult in ruleResult.Errors)
+                        {
+                            var error = techResult.Error;
+                            Console.WriteLine(error.ErrorMessage);
+                            if (error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                            {
+                                var element = (Aspose.Html.HTMLElement)error.Target.Item;
+                                Console.WriteLine(element.OuterHTML);
+                            }
+                        }
+                    }
+                }
+            }
+            else
+            {
+                Console.WriteLine("Document passed accessibility validation.");
+            }
+
+            // Clean up temporary file
+            if (File.Exists(tempFile))
+                File.Delete(tempFile);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/configure_accessibilityvalidator_custom_settings_before_validating_html_document_application.cs b/web-accessibility/configure_accessibilityvalidator_custom_settings_before_validating_html_document_application.cs
new file mode 100644
index 0000000..3d03470
--- /dev/null
+++ b/web-accessibility/configure_accessibilityvalidator_custom_settings_before_validating_html_document_application.cs
@@ -0,0 +1,78 @@
+// Configure an AccessibilityValidator with custom settings before validating an HTML document in the application.
+
+using System;
+using System.IO;
+using System.Text;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare a simple HTML file
+            string htmlContent = @"<!DOCTYPE html>
+<html>
+<head>
+    <title>Sample</title>
+</head>
+<body>
+    <h1 id='header'>Hello World</h1>
+    <img src='image.png' alt='Sample Image' />
+</body>
+</html>";
+            string tempFilePath = Path.Combine(Path.GetTempPath(), "sample.html");
+            File.WriteAllText(tempFilePath, htmlContent, Encoding.UTF8);
+
+            // Initialize WebAccessibility and validator
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load the HTML document
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(tempFilePath))
+            {
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (validationResult.Success)
+                {
+                    Console.WriteLine("Accessibility validation succeeded. No issues found.");
+                }
+                else
+                {
+                    Console.WriteLine("Accessibility validation failed. Details:");
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                // Print the error message
+                                Console.WriteLine($"Error: {techResult.Error.ErrorMessage}");
+
+                                // If the target is an HTML element, print additional info
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    string idAttribute = element.GetAttribute("id");
+                                    Console.WriteLine($"  Element: <{tagName}> Id: {idAttribute}");
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Clean up temporary file
+            if (File.Exists(tempFilePath))
+            {
+                File.Delete(tempFilePath);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"An error occurred: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/configure_validator_ignore_selected_rule_codes_allowing_custom_compliance_thresholds_during_checks.cs b/web-accessibility/configure_validator_ignore_selected_rule_codes_allowing_custom_compliance_thresholds_during_checks.cs
new file mode 100644
index 0000000..4819840
--- /dev/null
+++ b/web-accessibility/configure_validator_ignore_selected_rule_codes_allowing_custom_compliance_thresholds_during_checks.cs
@@ -0,0 +1,79 @@
+// Configure the validator to ignore selected rule codes, allowing custom compliance thresholds during checks.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>";
+
+            // Write the sample HTML to a temporary file
+            string tempFilePath = Path.Combine(Path.GetTempPath(), "sample.html");
+            File.WriteAllText(tempFilePath, htmlContent);
+
+            // Load the HTML document
+            var document = new Aspose.Html.HTMLDocument(tempFilePath);
+
+            // Create WebAccessibility instance
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+            // Create a validator for all rules
+            var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Validate the document
+            var validationResult = validator.Validate(document);
+
+            if (!validationResult.Success)
+            {
+                Console.WriteLine("Validation failed. Details:");
+                foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                {
+                    Console.WriteLine($"Rule: {detail.Rule.Code} - {detail.Rule.Description} - Success: {detail.Success}");
+                    if (!detail.Success)
+                    {
+                        foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in detail.Errors)
+                        {
+                            var target = techResult.Error.Target;
+                            if (target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                            {
+                                var element = (Aspose.Html.HTMLElement)target.Item;
+                                Console.WriteLine($"  Element: <{element.TagName}> OuterHTML: {element.OuterHTML}");
+                            }
+                            else
+                            {
+                                Console.WriteLine($"  Target type: {target.TargetType}");
+                            }
+                        }
+                    }
+                }
+            }
+            else
+            {
+                Console.WriteLine("Validation succeeded with no errors.");
+            }
+
+            // Example: Validate a specific guideline under a principle
+            var principle = webAccessibility.Rules.GetPrinciple("WCAG2AA");
+            var guideline = principle.GetGuideline("1.1.1"); // Example guideline code
+            var validator2 = webAccessibility.CreateValidator(guideline, Aspose.Html.Accessibility.ValidationBuilder.All);
+            var validationResult2 = validator2.Validate(document);
+            if (!validationResult2.Success)
+            {
+                Console.WriteLine("Guideline validation failed.");
+            }
+            else
+            {
+                Console.WriteLine("Guideline validation succeeded.");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/configure_validator_static_rule_repository_consistent_rule_application_across_runs.cs b/web-accessibility/configure_validator_static_rule_repository_consistent_rule_application_across_runs.cs
new file mode 100644
index 0000000..fadb359
--- /dev/null
+++ b/web-accessibility/configure_validator_static_rule_repository_consistent_rule_application_across_runs.cs
@@ -0,0 +1,69 @@
+// Configure the validator to use a static rule repository for consistent rule application across runs.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare a simple HTML content and save it to a temporary file
+            string htmlContent = @"<!DOCTYPE html>
+<html>
+<head>
+    <title>Sample Page</title>
+</head>
+<body>
+    <h1>Hello, Aspose.HTML!</h1>
+    <p>This is a sample HTML document for accessibility validation.</p>
+</body>
+</html>";
+
+            string tempFilePath = Path.Combine(Path.GetTempPath(), "sample.html");
+            File.WriteAllText(tempFilePath, htmlContent);
+
+            // Initialize WebAccessibility and create a validator for all rules
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load the HTML document
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(tempFilePath);
+
+            // Perform validation
+            Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+            // Output validation results
+            if (!validationResult.Success)
+            {
+                Console.WriteLine("Accessibility validation failed. Details:");
+                foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                {
+                    string ruleCode = detail.Rule?.Code ?? "N/A";
+                    string ruleDescription = detail.Rule?.Description ?? "No description";
+                    Console.WriteLine($"Rule: {ruleCode}");
+                    Console.WriteLine($"Description: {ruleDescription}");
+                    Console.WriteLine($"Success: {detail.Success}");
+                    Console.WriteLine(new string('-', 40));
+                }
+            }
+            else
+            {
+                Console.WriteLine("Accessibility validation succeeded. No issues found.");
+            }
+
+            // Clean up
+            document.Dispose();
+            // Optionally delete the temporary file
+            if (File.Exists(tempFilePath))
+            {
+                File.Delete(tempFilePath);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/configure_validator_treat_caption_missing_warnings_as_errors_adjust_severity_settings.cs b/web-accessibility/configure_validator_treat_caption_missing_warnings_as_errors_adjust_severity_settings.cs
new file mode 100644
index 0000000..9be2bab
--- /dev/null
+++ b/web-accessibility/configure_validator_treat_caption_missing_warnings_as_errors_adjust_severity_settings.cs
@@ -0,0 +1,45 @@
+// Configure the validator to treat caption missing warnings as errors by adjusting severity settings.
+
+using System;
+using System.IO;
+using System.Text;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string html = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1></body></html>";
+
+            using (var document = new Aspose.Html.HTMLDocument(new MemoryStream(Encoding.UTF8.GetBytes(html)), ""))
+            {
+                var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+                var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+                var validationResult = validator.Validate(document);
+
+                if (validationResult.Success)
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+                else
+                {
+                    foreach (var ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (var techResult in ruleResult.Errors)
+                            {
+                                Console.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/create_custom_rule_subset_selecting_specific_wcag_criteria_from_accessibilityrules_before_validation.cs b/web-accessibility/create_custom_rule_subset_selecting_specific_wcag_criteria_from_accessibilityrules_before_validation.cs
new file mode 100644
index 0000000..e00f468
--- /dev/null
+++ b/web-accessibility/create_custom_rule_subset_selecting_specific_wcag_criteria_from_accessibilityrules_before_validation.cs
@@ -0,0 +1,91 @@
+// Create a custom rule subset by selecting specific WCAG criteria from AccessibilityRules before validation.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare a minimal HTML file
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1></body></html>";
+            string inputPath = Path.Combine(Directory.GetCurrentDirectory(), "sample.html");
+            File.WriteAllText(inputPath, htmlContent);
+
+            // Create WebAccessibility instance
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+            // Create validator with all rules
+            var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load the document and validate
+            using (var document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Console.WriteLine(techResult.Error.ErrorMessage);
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+            }
+
+            // Retrieve a specific principle, guideline, and criterion
+            // Example codes are illustrative; replace with actual codes as needed
+            string principleCode = "Principle1";
+            string guidelineCode = "Guideline1";
+            string criterionCode = "Criterion1";
+
+            Aspose.Html.Accessibility.Principle principle = webAccessibility.Rules.GetPrinciple(principleCode);
+            if (principle != null)
+            {
+                Aspose.Html.Accessibility.Guideline guideline = principle.GetGuideline(guidelineCode);
+                if (guideline != null)
+                {
+                    Aspose.Html.Accessibility.Criterion criterion = guideline.GetCriterion(criterionCode);
+                    if (criterion != null)
+                    {
+                        Console.WriteLine("{0}:{1} - {2}", criterion.Code, criterion.Description, criterion.Level);
+                        foreach (Aspose.Html.Accessibility.IRule technique in criterion.SufficientTechniques)
+                        {
+                            Console.WriteLine("{0}:{1}", technique.Code, technique.Description);
+                        }
+                    }
+                    else
+                    {
+                        Console.WriteLine("Criterion not found.");
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Guideline not found.");
+                }
+            }
+            else
+            {
+                Console.WriteLine("Principle not found.");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/create_powershell_script_loads_dotnet_library_validates_html_file_prints_json_results.cs b/web-accessibility/create_powershell_script_loads_dotnet_library_validates_html_file_prints_json_results.cs
new file mode 100644
index 0000000..17b894e
--- /dev/null
+++ b/web-accessibility/create_powershell_script_loads_dotnet_library_validates_html_file_prints_json_results.cs
@@ -0,0 +1,50 @@
+// Create a PowerShell script that loads the .NET library, validates an HTML file, and prints JSON results.
+
+using System;
+using System.IO;
+using System.Text.Json;
+using Aspose.Html;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+
+public class Program
+{
+    public static void Main()
+    {
+        try
+        {
+            string inputPath = "sample.html";
+            if (!File.Exists(inputPath))
+            {
+                File.WriteAllText(inputPath, "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello World</h1></body></html>");
+            }
+
+            WebAccessibility webAccessibility = new WebAccessibility();
+            AccessibilityValidator validator = webAccessibility.CreateValidator(ValidationBuilder.All);
+            HTMLDocument document = new HTMLDocument(inputPath);
+            ValidationResult validationResult = validator.Validate(document);
+
+            int failedCount = 0;
+            foreach (RuleValidationResult detail in validationResult.Details)
+            {
+                if (!detail.Success)
+                {
+                    failedCount++;
+                }
+            }
+
+            var resultObj = new
+            {
+                Success = validationResult.Success,
+                FailedRules = failedCount
+            };
+
+            string json = JsonSerializer.Serialize(resultObj);
+            Console.WriteLine(json);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/create_static_accessibilityvalidator_instance_and_reuse_to_validate_multiple_html_files_efficiently.cs b/web-accessibility/create_static_accessibilityvalidator_instance_and_reuse_to_validate_multiple_html_files_efficiently.cs
new file mode 100644
index 0000000..c20f67f
--- /dev/null
+++ b/web-accessibility/create_static_accessibilityvalidator_instance_and_reuse_to_validate_multiple_html_files_efficiently.cs
@@ -0,0 +1,50 @@
+// Create a static AccessibilityValidator instance and reuse it to validate multiple HTML files efficiently.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare a simple HTML file for validation
+            string htmlPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "sample.html");
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src='missing.jpg'></body></html>";
+            System.IO.File.WriteAllText(htmlPath, htmlContent);
+
+            // Initialize accessibility validator
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load the document and perform validation
+            using (var document = new Aspose.Html.HTMLDocument(htmlPath))
+            {
+                var validationResult = validator.Validate(document);
+
+                if (validationResult.Success)
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+                else
+                {
+                    foreach (var ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (var techResult in ruleResult.Errors)
+                            {
+                                var error = techResult.Error;
+                                Console.WriteLine(error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/create_validator_instance_using_createvalidator_before_loading_html_document_for_accessibility.cs b/web-accessibility/create_validator_instance_using_createvalidator_before_loading_html_document_for_accessibility.cs
new file mode 100644
index 0000000..7d3a59e
--- /dev/null
+++ b/web-accessibility/create_validator_instance_using_createvalidator_before_loading_html_document_for_accessibility.cs
@@ -0,0 +1,57 @@
+// Create a validator instance using CreateValidator() before loading any HTML document for accessibility.
+
+using System;
+using System.IO;
+using System.Text;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Create a simple HTML file for validation
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>";
+            string tempFilePath = Path.Combine(Path.GetTempPath(), "sample.html");
+            File.WriteAllText(tempFilePath, htmlContent, Encoding.UTF8);
+
+            // Initialize accessibility validator
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load the HTML document and perform validation
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(tempFilePath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (validationResult.Success)
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+                else
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                Console.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Clean up temporary file
+            if (File.Exists(tempFilePath))
+            {
+                File.Delete(tempFilePath);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/detect_absent_caption_files_referenced_by_track_elements_log_file_paths.cs b/web-accessibility/detect_absent_caption_files_referenced_by_track_elements_log_file_paths.cs
new file mode 100644
index 0000000..921a6fd
--- /dev/null
+++ b/web-accessibility/detect_absent_caption_files_referenced_by_track_elements_log_file_paths.cs
@@ -0,0 +1,93 @@
+// Detect absent caption files referenced by <track> elements and log their file paths.
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+using Aspose.Html;
+using Aspose.Html.Dom;
+using Aspose.Html.Dom.XPath;
+using Aspose.Html.Collections;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Paths
+            string logPath = "log.txt";
+            string inputPath = "input.html";
+            string outputPath = "output.html";
+
+            // Create a minimal sample HTML file if it does not exist
+            if (!File.Exists(inputPath))
+            {
+                string sampleHtml = @"<!DOCTYPE html>
+<html>
+<head><title>Sample</title></head>
+<body>
+    <img src='image1.png' />
+    <script>console.log('test');</script>
+    <img src='image2.png' alt='' />
+</body>
+</html>";
+                File.WriteAllText(inputPath, sampleHtml);
+            }
+
+            // Load document
+            Aspose.Html.HTMLDocument doc = new Aspose.Html.HTMLDocument(inputPath);
+
+            // Log all image src attributes using XPath
+            Aspose.Html.Dom.XPath.IXPathResult result = doc.Evaluate(
+                "//img",
+                doc,
+                doc.CreateNSResolver(doc),
+                Aspose.Html.Dom.XPath.XPathResultType.Any,
+                null);
+
+            Aspose.Html.Dom.Node node;
+            while ((node = result.IterateNext()) != null)
+            {
+                Aspose.Html.HTMLImageElement img = node as Aspose.Html.HTMLImageElement;
+                if (img != null)
+                {
+                    File.AppendAllText(logPath, img.Src + Environment.NewLine);
+                }
+            }
+
+            // Remove all <script> elements safely
+            Aspose.Html.Collections.HTMLCollection scripts = doc.GetElementsByTagName("script");
+            for (int i = scripts.Length - 1; i >= 0; i--)
+            {
+                Aspose.Html.Dom.Element script = scripts[i] as Aspose.Html.Dom.Element;
+                if (script != null && script.ParentNode != null)
+                {
+                    script.ParentNode.RemoveChild(script);
+                }
+            }
+
+            // Ensure every <img> has a non‑empty alt attribute
+            Aspose.Html.Collections.HTMLCollection images = doc.GetElementsByTagName("img");
+            foreach (Aspose.Html.Dom.Element imgElement in images)
+            {
+                Aspose.Html.HTMLImageElement img = imgElement as Aspose.Html.HTMLImageElement;
+                if (img != null)
+                {
+                    string alt = img.GetAttribute("alt");
+                    if (string.IsNullOrWhiteSpace(alt))
+                    {
+                        string autoAlt = "auto-generated alt";
+                        img.SetAttribute("alt", autoAlt);
+                    }
+                }
+            }
+
+            // Save the modified document
+            doc.Save(outputPath);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/develop_command_line_tool_accepting_input_path_and_output_format_arguments_to_perform_validation_on_demand.cs b/web-accessibility/develop_command_line_tool_accepting_input_path_and_output_format_arguments_to_perform_validation_on_demand.cs
new file mode 100644
index 0000000..37b9027
--- /dev/null
+++ b/web-accessibility/develop_command_line_tool_accepting_input_path_and_output_format_arguments_to_perform_validation_on_demand.cs
@@ -0,0 +1,42 @@
+// Develop a command‑line tool accepting input path and output format arguments to perform validation on demand.
+
+using System;
+using System.IO;
+class Program
+{
+    static void Main(string[] args)
+    {
+        string inputPath = args.Length > 0 ? args[0] : "sample.html";
+        string format = args.Length > 1 ? args[1].ToLowerInvariant() : "string";
+        if (!File.Exists(inputPath))
+        {
+            File.WriteAllText(inputPath, "<!DOCTYPE html><html><head><title>Sample</title></head><body><p>Hello</p></body></html>");
+        }
+        try
+        {
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+                Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator();
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                if (format == "xml")
+                {
+                    using (StringWriter sw = new StringWriter())
+                    {
+                        validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                        Console.WriteLine(sw.ToString());
+                    }
+                }
+                else
+                {
+                    string resultString = validationResult.SaveToString();
+                    Console.WriteLine(resultString);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/embed_validation_results_string_into_email_body_notify_stakeholders_accessibility_status.cs b/web-accessibility/embed_validation_results_string_into_email_body_notify_stakeholders_accessibility_status.cs
new file mode 100644
index 0000000..9b0526a
--- /dev/null
+++ b/web-accessibility/embed_validation_results_string_into_email_body_notify_stakeholders_accessibility_status.cs
@@ -0,0 +1,71 @@
+// Embed validation results string into an email body to notify stakeholders of accessibility status.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare a simple HTML file with an element that will fail accessibility validation
+            string htmlContent = @"<!DOCTYPE html>
+<html>
+<head><title>Test</title></head>
+<body>
+    <img src='image.png'>
+    <a href='https://example.com'>Link</a>
+</body>
+</html>";
+            string tempFilePath = Path.Combine(Path.GetTempPath(), "sample.html");
+            File.WriteAllText(tempFilePath, htmlContent);
+
+            // Create WebAccessibility instance and validator
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load the HTML document
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(tempFilePath))
+            {
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    // Example: retrieve the "src" attribute if present
+                                    string attributeValue = element.GetAttribute("src") ?? element.GetAttribute("href") ?? string.Empty;
+                                    Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Document passed accessibility validation successfully.");
+                }
+            }
+
+            // Clean up temporary file
+            if (File.Exists(tempFilePath))
+            {
+                File.Delete(tempFilePath);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/embed_vtt_caption_file_into_html_document_and_reference_with_new_track_element.cs b/web-accessibility/embed_vtt_caption_file_into_html_document_and_reference_with_new_track_element.cs
new file mode 100644
index 0000000..8687292
--- /dev/null
+++ b/web-accessibility/embed_vtt_caption_file_into_html_document_and_reference_with_new_track_element.cs
@@ -0,0 +1,40 @@
+// Embed a .vtt caption file into the HTML document and reference it via a newly created <track> element.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Create a new HTML document
+            var document = new Aspose.Html.HTMLDocument();
+
+            // Get the body element
+            Aspose.Html.HTMLElement body = document.Body;
+
+            // Create an <img> element
+            Aspose.Html.Dom.Element imgElement = document.CreateElement("img");
+            Aspose.Html.HTMLImageElement img = (Aspose.Html.HTMLImageElement)imgElement;
+            img.Src = "https://docs.aspose.com/html/images/aspose-html-for-net.png";
+            img.Alt = "Aspose.HTML for .NET Product Logo";
+            img.Width = 128;
+            img.Height = 128;
+
+            // Append the image to the body
+            body.AppendChild(img);
+
+            // Save the document to a file
+            string outputPath = Path.Combine(Directory.GetCurrentDirectory(), "output.html");
+            document.Save(outputPath);
+
+            Console.WriteLine($"HTML document saved to: {outputPath}");
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/ensure_caption_tracks_contain_synchronized_timestamps_matching_associated_media_timeline.cs b/web-accessibility/ensure_caption_tracks_contain_synchronized_timestamps_matching_associated_media_timeline.cs
new file mode 100644
index 0000000..e852335
--- /dev/null
+++ b/web-accessibility/ensure_caption_tracks_contain_synchronized_timestamps_matching_associated_media_timeline.cs
@@ -0,0 +1,114 @@
+// Ensure caption tracks contain synchronized timestamps matching the associated media timeline.
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+using Aspose.Html.IO;
+
+class MemoryStreamProvider : Aspose.Html.IO.ICreateStreamProvider, IDisposable
+{
+    private readonly List<MemoryStream> _streams = new List<MemoryStream>();
+
+    public IReadOnlyList<MemoryStream> Streams => _streams;
+
+    public Stream GetStream(string name, string extension)
+    {
+        var ms = new MemoryStream();
+        _streams.Add(ms);
+        return ms;
+    }
+
+    public Stream GetStream(string name, string extension, int page)
+    {
+        var ms = new MemoryStream();
+        _streams.Add(ms);
+        return ms;
+    }
+
+    public void ReleaseStream(Stream stream)
+    {
+        // No action needed; streams are kept for later use.
+    }
+
+    public void Dispose()
+    {
+        foreach (var ms in _streams)
+        {
+            ms.Dispose();
+        }
+        _streams.Clear();
+    }
+}
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare sample HTML file
+            string htmlContent = "<html><body><p>First paragraph.</p><p>Second paragraph.</p></body></html>";
+            string currentDir = Directory.GetCurrentDirectory();
+            string inputHtmlPath = Path.Combine(currentDir, "sample.html");
+            File.WriteAllText(inputHtmlPath, htmlContent);
+
+            // Load HTML document
+            var document = new Aspose.Html.HTMLDocument(inputHtmlPath);
+
+            // Get all paragraph elements
+            var paragraphs = document.GetElementsByTagName("p");
+            if (paragraphs.Length >= 2)
+            {
+                // Create an image element
+                var img = document.CreateElement("img");
+                img.SetAttribute("src", "https://via.placeholder.com/150");
+                img.SetAttribute("alt", "Placeholder Image");
+
+                // Insert the image after the second paragraph
+                var secondParagraph = (Aspose.Html.Dom.Element)paragraphs[1];
+                secondParagraph.ParentNode.InsertBefore(img, secondParagraph.NextSibling);
+            }
+
+            // Save modified HTML
+            string outputHtmlPath = Path.Combine(currentDir, "output.html");
+            var saveOptions = new Aspose.Html.Saving.HTMLSaveOptions();
+            document.Save(outputHtmlPath, saveOptions);
+
+            // Load document from URL with timeout
+            string url = "https://example.com";
+            var request = new Aspose.Html.Net.RequestMessage(url);
+            request.Timeout = TimeSpan.FromSeconds(10);
+            var urlDocument = new Aspose.Html.HTMLDocument(request);
+            string urlHtml = ((Aspose.Html.HTMLElement)urlDocument.DocumentElement).OuterHTML;
+
+            // Add watermark using DOM overlay (as per task intent)
+            var div = document.CreateElement("div");
+            div.SetAttribute("style", "position:absolute;top:10px;left:10px;color:red;font-size:24px;");
+            div.TextContent = "Watermark";
+            document.Body.AppendChild(div);
+
+            // Convert HTML to JPEG image using a stream provider
+            var imageOptions = new Aspose.Html.Saving.ImageSaveOptions(Aspose.Html.Rendering.Image.ImageFormat.Jpeg);
+            using (var provider = new MemoryStreamProvider())
+            {
+                Aspose.Html.Converters.Converter.ConvertHTML(document, imageOptions, provider);
+                if (provider.Streams.Count > 0)
+                {
+                    var memory = provider.Streams[0];
+                    memory.Seek(0, SeekOrigin.Begin);
+                    string outputImagePath = Path.Combine(currentDir, "output.jpg");
+                    using (var fs = File.Create(outputImagePath))
+                    {
+                        memory.CopyTo(fs);
+                    }
+                }
+            }
+
+            Console.WriteLine("Processing completed successfully.");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/exclude_keyboard_navigation_warnings_from_final_report_apply_result_filtering_option.cs b/web-accessibility/exclude_keyboard_navigation_warnings_from_final_report_apply_result_filtering_option.cs
new file mode 100644
index 0000000..47a556c
--- /dev/null
+++ b/web-accessibility/exclude_keyboard_navigation_warnings_from_final_report_apply_result_filtering_option.cs
@@ -0,0 +1,105 @@
+// Exclude keyboard navigation warnings from the final report by applying a result‑filtering option.
+
+using System;
+using System.IO;
+using System.Text.RegularExpressions;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare sample HTML file
+            string inputPath = "sample.html";
+            if (!File.Exists(inputPath))
+            {
+                string sampleHtml = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src='image.png' alt=''></body></html>";
+                File.WriteAllText(inputPath, sampleHtml);
+            }
+
+            string outputPath = "output.mhtml";
+
+            // Accessibility validation
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (var document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                var validationResult = validator.Validate(document);
+                if (!validationResult.Success)
+                {
+                    foreach (var ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (var techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    var element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    string attributeValue = element.GetAttribute("alt");
+                                    Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Retrieve principle, guideline, and criterion information
+            var principle = webAccessibility.Rules.GetPrinciple("1.1");
+            if (principle != null)
+            {
+                var guideline = principle.GetGuideline("1.1.1");
+                if (guideline != null)
+                {
+                    var criterion = guideline.GetCriterion("1.1.1.1");
+                    if (criterion != null)
+                    {
+                        Console.WriteLine($"{criterion.Code}:{criterion.Description} - {criterion.Level}");
+                        foreach (var technique in criterion.SufficientTechniques)
+                        {
+                            Console.WriteLine($"{technique.Code}:{technique.Description}");
+                        }
+                    }
+                }
+            }
+
+            // Configure network service with custom message handler
+            var configuration = new Aspose.Html.Configuration();
+            var networkService = configuration.GetService<Aspose.Html.Services.INetworkService>();
+            networkService.MessageHandlers.Add(new ExcludeUrlMessageHandler());
+
+            // Load document via request (using file URI) and convert to MHTML
+            string fileUri = new Uri(Path.GetFullPath(inputPath)).AbsoluteUri;
+            var request = new Aspose.Html.Net.RequestMessage(fileUri);
+            using (var document = new Aspose.Html.HTMLDocument(request, configuration))
+            {
+                var options = new Aspose.Html.Saving.MHTMLSaveOptions();
+                Aspose.Html.Converters.Converter.ConvertHTML(document, options, outputPath);
+            }
+
+            Console.WriteLine("Processing completed successfully.");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
+
+// Custom message handler to exclude specific URLs
+class ExcludeUrlMessageHandler : Aspose.Html.Net.MessageHandler
+{
+    private readonly Regex _excludeRegex = new Regex(@"\.png$", RegexOptions.Compiled | RegexOptions.IgnoreCase);
+    public override void Invoke(Aspose.Html.Net.INetworkOperationContext context)
+    {
+        string urlText = context.Request.RequestUri.ToString();
+        if (_excludeRegex.IsMatch(urlText))
+        {
+            return;
+        }
+        Next(context);
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/execute_validate_method_assess_multimedia_accessibility_loaded_html_document.cs b/web-accessibility/execute_validate_method_assess_multimedia_accessibility_loaded_html_document.cs
new file mode 100644
index 0000000..666ae44
--- /dev/null
+++ b/web-accessibility/execute_validate_method_assess_multimedia_accessibility_loaded_html_document.cs
@@ -0,0 +1,72 @@
+// Execute the Validate method to assess multimedia accessibility of the loaded HTML document.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Initialize WebAccessibility
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+            // Obtain a specific guideline (example: WCAG 2.0 AA, guideline 1.1.1)
+            Aspose.Html.Accessibility.Guideline guideline = webAccessibility.Rules
+                .GetPrinciple("WCAG2AA")
+                .GetGuideline("1.1.1");
+
+            // Create a validator for the selected guideline
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(
+                guideline,
+                Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Sample HTML content to validate
+            string htmlContent = @"
+                <html>
+                    <head><title>Sample</title></head>
+                    <body>
+                        <img src='image.png' alt=''>
+                        <a href='https://example.com'>Link</a>
+                    </body>
+                </html>";
+
+            // Load the HTML document
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent))
+            {
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                // If validation failed, output details
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    // Example: retrieve the 'alt' attribute if present
+                                    string attributeValue = element.GetAttribute("alt");
+                                    Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Document passed accessibility validation successfully.");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/execute_validator_validate_with_file_path_to_run_accessibility_checks_on_page.cs b/web-accessibility/execute_validator_validate_with_file_path_to_run_accessibility_checks_on_page.cs
new file mode 100644
index 0000000..25d4a31
--- /dev/null
+++ b/web-accessibility/execute_validator_validate_with_file_path_to_run_accessibility_checks_on_page.cs
@@ -0,0 +1,74 @@
+// Execute validator.Validate with the file path to run accessibility checks on the page.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Create a minimal HTML file for validation
+            string htmlPath = "sample.html";
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1></body></html>";
+            File.WriteAllText(htmlPath, htmlContent);
+
+            // Validate the document against all accessibility rules
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (var document = new Aspose.Html.HTMLDocument(htmlPath))
+            {
+                var validationResult = validator.Validate(document);
+                if (validationResult.Success)
+                {
+                    Console.WriteLine("Document passed all accessibility checks.");
+                }
+                else
+                {
+                    foreach (var ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (var techResult in ruleResult.Errors)
+                            {
+                                Console.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Validate the document against a specific guideline (example: WCAG 2.0 Guideline 1.1.1)
+            var principle = webAccessibility.Rules.GetPrinciple("WCAG2.0");
+            var guideline = principle.GetGuideline("1.1.1");
+            var validator2 = webAccessibility.CreateValidator(guideline, Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (var document2 = new Aspose.Html.HTMLDocument(htmlPath))
+            {
+                var validationResult2 = validator2.Validate(document2);
+                if (!validationResult2.Success)
+                {
+                    Console.WriteLine("Specific guideline validation errors:");
+                    foreach (var ruleResult in validationResult2.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (var techResult in ruleResult.Errors)
+                            {
+                                Console.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Specific guideline passed.");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/export_validation_results_formatted_string_developer_review.cs b/web-accessibility/export_validation_results_formatted_string_developer_review.cs
new file mode 100644
index 0000000..c78b848
--- /dev/null
+++ b/web-accessibility/export_validation_results_formatted_string_developer_review.cs
@@ -0,0 +1,71 @@
+// Export validation results as a formatted string using SaveToString for developer review.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello World</h1></body></html>";
+            string baseUri = "http://example.com/";
+
+            // -----------------------------------------------------------------
+            // 1. Convert HTML to MHTML
+            // -----------------------------------------------------------------
+            string mhtmlOutputPath = "output.mhtml";
+            var mhtmlOptions = new Aspose.Html.Saving.MHTMLSaveOptions();
+            Aspose.Html.Converters.Converter.ConvertHTML(htmlContent, baseUri, mhtmlOptions, mhtmlOutputPath);
+            Console.WriteLine($"MHTML saved to: {mhtmlOutputPath}");
+
+            // -----------------------------------------------------------------
+            // 2. Accessibility validation
+            // -----------------------------------------------------------------
+            string htmlFilePath = "sample.html";
+            File.WriteAllText(htmlFilePath, htmlContent);
+
+            using (var document = new Aspose.Html.HTMLDocument(htmlFilePath))
+            {
+                var validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+                var validationResult = validator.Validate(document);
+
+                string validationXml;
+                using (var sw = new StringWriter())
+                {
+                    validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                    validationXml = sw.ToString();
+                }
+
+                Console.WriteLine("Accessibility validation result (XML):");
+                Console.WriteLine(validationXml);
+            }
+
+            // -----------------------------------------------------------------
+            // 3. Save as Markdown (file path overload)
+            // -----------------------------------------------------------------
+            string markdownPath1 = "output1.md";
+            using (var doc = new Aspose.Html.HTMLDocument(htmlFilePath))
+            {
+                doc.Save(markdownPath1, Aspose.Html.Saving.HTMLSaveFormat.Markdown);
+            }
+            Console.WriteLine($"Markdown saved to: {markdownPath1}");
+
+            // -----------------------------------------------------------------
+            // 4. Save as Markdown (HTML string + base URI overload)
+            // -----------------------------------------------------------------
+            string markdownPath2 = "output2.md";
+            using (var doc = new Aspose.Html.HTMLDocument(htmlContent, baseUri))
+            {
+                doc.Save(markdownPath2, Aspose.Html.Saving.HTMLSaveFormat.Markdown);
+            }
+            Console.WriteLine($"Markdown saved to: {markdownPath2}");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/fail_build_if_critical_accessibility_errors_detected_enforce_quality_gates.cs b/web-accessibility/fail_build_if_critical_accessibility_errors_detected_enforce_quality_gates.cs
new file mode 100644
index 0000000..a029980
--- /dev/null
+++ b/web-accessibility/fail_build_if_critical_accessibility_errors_detected_enforce_quality_gates.cs
@@ -0,0 +1,73 @@
+// Fail the build if any critical accessibility errors are detected to enforce quality gates.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Create a temporary HTML file with sample content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1><img src='missing.jpg' alt=''></body></html>";
+            string inputPath = Path.Combine(Path.GetTempPath(), "sample.html");
+            File.WriteAllText(inputPath, htmlContent);
+
+            // Initialize WebAccessibility and a validator that checks all rules
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Validate the whole document
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                if (validationResult.Success)
+                {
+                    Console.WriteLine("Document passed all accessibility checks.");
+                }
+                else
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    string attributeValue = element.GetAttribute("alt");
+                                    Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                                else
+                                {
+                                    Console.WriteLine(techResult.Error.ErrorMessage);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Validate a specific guideline (example: Perceivable -> TextAlternatives)
+            Aspose.Html.Accessibility.Principle principle = webAccessibility.Rules.GetPrinciple("Perceivable");
+            Aspose.Html.Accessibility.Guideline guideline = principle.GetGuideline("TextAlternatives");
+            Aspose.Html.Accessibility.AccessibilityValidator guidelineValidator = webAccessibility.CreateValidator(guideline, Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            using (Aspose.Html.HTMLDocument docForGuideline = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult guidelineResult = guidelineValidator.Validate(docForGuideline);
+                Console.WriteLine($"Guideline validation success: {guidelineResult.Success}");
+            }
+
+            // Clean up temporary file
+            File.Delete(inputPath);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/fail_ci_build_validationresult_contains_error_level_findings_enforce_accessibility_standards.cs b/web-accessibility/fail_ci_build_validationresult_contains_error_level_findings_enforce_accessibility_standards.cs
new file mode 100644
index 0000000..048ef6d
--- /dev/null
+++ b/web-accessibility/fail_ci_build_validationresult_contains_error_level_findings_enforce_accessibility_standards.cs
@@ -0,0 +1,68 @@
+// Fail a CI build when ValidationResult contains any error‑level findings to enforce accessibility standards.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>";
+
+            // Create WebAccessibility and validator
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // First validation: print errors for HTMLElement targets only
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Console.WriteLine(techResult.Error.ErrorMessage);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Second validation: print success message or all error messages
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                if (validationResult.Success)
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+                else
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                Console.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/fetch_html_content_url_list_validate_pages_save_results_xml_files.cs b/web-accessibility/fetch_html_content_url_list_validate_pages_save_results_xml_files.cs
new file mode 100644
index 0000000..81ca552
--- /dev/null
+++ b/web-accessibility/fetch_html_content_url_list_validate_pages_save_results_xml_files.cs
@@ -0,0 +1,73 @@
+// Fetch HTML content from a list of URLs, validate each page, and save results as XML files.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare URLs to validate
+            System.Collections.Generic.List<string> urls = new System.Collections.Generic.List<string>
+            {
+                "https://example.com",
+                "https://example.org"
+            };
+
+            // Ensure output directory exists
+            System.IO.Directory.CreateDirectory("output");
+
+            // Initialize accessibility validator
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            int index = 1;
+            foreach (string url in urls)
+            {
+                using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(url))
+                {
+                    Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                    string outputPath = System.IO.Path.Combine("output", $"validation_result_{index}.xml");
+                    System.IO.File.WriteAllText(outputPath, validationResult.ToString());
+                }
+                index++;
+            }
+
+            // Create a minimal sample HTML file with a table if it does not exist
+            string sampleFilePath = "sample.html";
+            if (!System.IO.File.Exists(sampleFilePath))
+            {
+                string sampleContent = @"<html><body><table><tr><td>Cell</td></tr></table></body></html>";
+                System.IO.File.WriteAllText(sampleFilePath, sampleContent);
+            }
+
+            // Load the sample document and process tables
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(sampleFilePath))
+            {
+                Aspose.Html.Collections.HTMLCollection tables = document.GetElementsByTagName("table");
+                if (tables != null && tables.Length > 0)
+                {
+                    int i = 0;
+                    foreach (Aspose.Html.Dom.Element table in tables)
+                    {
+                        string newFileName = $"checked-web-table{i}.html";
+                        string tablePath = System.IO.Path.Combine("output", newFileName);
+                        // Write the outer HTML of the table to a file
+                        System.IO.File.WriteAllText(tablePath, table.ToString());
+                        i++;
+                    }
+                }
+            }
+
+            Console.WriteLine("Processing completed successfully.");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/filter_errors_by_target_type_separate_html_element_issues_from_css_problems.cs b/web-accessibility/filter_errors_by_target_type_separate_html_element_issues_from_css_problems.cs
new file mode 100644
index 0000000..d194e38
--- /dev/null
+++ b/web-accessibility/filter_errors_by_target_type_separate_html_element_issues_from_css_problems.cs
@@ -0,0 +1,78 @@
+// Filter errors by Target.TargetTypes to separate HTML element issues from CSS related problems.
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Drawing;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content
+            string html = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src='image.png'><div><p>Hello</p></div></body></html>";
+
+            // Initialize WebAccessibility
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+            // Create a validator for all rules
+            var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load the HTML document from the string
+            using (var document = new Aspose.Html.HTMLDocument(html))
+            {
+                // Perform validation
+                var validationResult = validator.Validate(document);
+
+                if (!validationResult.Success)
+                {
+                    foreach (var ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (var techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    var element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    string attributeValue = element.GetAttribute("alt");
+                                    Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+
+                // Retrieve a specific principle and guideline, then validate against that guideline
+                var principle = webAccessibility.Rules.GetPrinciple("Perceivable");
+                var guideline = principle.GetGuideline("Text Alternatives");
+                var guidelineValidator = webAccessibility.CreateValidator(guideline, Aspose.Html.Accessibility.ValidationBuilder.All);
+                var guidelineResult = guidelineValidator.Validate(document);
+                Console.WriteLine($"Guideline validation success: {guidelineResult.Success}");
+
+                // Query selector example: set background color for all <p> elements
+                var elements = document.QuerySelectorAll("p");
+                foreach (Aspose.Html.HTMLElement element in elements)
+                {
+                    element.Style.BackgroundColor = "aliceblue";
+                }
+
+                // Save the modified document
+                string outputPath = "output.html";
+                document.Save(outputPath);
+                Console.WriteLine($"Modified document saved to {outputPath}");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/filter_rule_set_include_only_error_level_criteria_before_validation_focus_critical_problems.cs b/web-accessibility/filter_rule_set_include_only_error_level_criteria_before_validation_focus_critical_problems.cs
new file mode 100644
index 0000000..a38b8ef
--- /dev/null
+++ b/web-accessibility/filter_rule_set_include_only_error_level_criteria_before_validation_focus_critical_problems.cs
@@ -0,0 +1,70 @@
+// Filter the rule set to include only error‑level criteria before validation to focus on critical problems.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content
+            string html = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1></body></html>";
+
+            // Create WebAccessibility instance
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+            // Create validator for all rules
+            var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load document from string
+            var document = new Aspose.Html.HTMLDocument(html);
+
+            // Perform validation
+            var validationResult = validator.Validate(document);
+
+            // Output overall success
+            Console.WriteLine("Validation Success: " + validationResult.Success);
+
+            // Iterate rule results
+            foreach (var detail in validationResult.Details)
+            {
+                Console.WriteLine($"Rule: {detail.Rule.Code} - {detail.Rule.Description} - Success: {detail.Success}");
+                if (!detail.Success)
+                {
+                    foreach (var techResult in detail.Errors)
+                    {
+                        if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                        {
+                            var element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                            Console.WriteLine($"  Element: <{element.TagName}>");
+                        }
+                    }
+                }
+            }
+
+            // Example: retrieve a specific principle, guideline, and criterion
+            var principle = webAccessibility.Rules.GetPrinciple("1.1");
+            if (principle != null)
+            {
+                var guideline = principle.GetGuideline("1.1.1");
+                if (guideline != null)
+                {
+                    var criterion = guideline.GetCriterion("1.1.1.1");
+                    if (criterion != null)
+                    {
+                        Console.WriteLine($"{criterion.Code}:{criterion.Description} - Level {criterion.Level}");
+                        foreach (var technique in criterion.SufficientTechniques)
+                        {
+                            Console.WriteLine($"{technique.Code}:{technique.Description}");
+                        }
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/filter_validation_results_audio_description_warnings_video_improvements.cs b/web-accessibility/filter_validation_results_audio_description_warnings_video_improvements.cs
new file mode 100644
index 0000000..82bb220
--- /dev/null
+++ b/web-accessibility/filter_validation_results_audio_description_warnings_video_improvements.cs
@@ -0,0 +1,59 @@
+// Filter validation results to display only audio‑description warnings for targeted video improvements.
+
+using System;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Create a minimal HTML file for validation
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src='image.png'></body></html>";
+            string inputPath = "sample.html";
+            File.WriteAllText(inputPath, htmlContent);
+
+            // Initialize WebAccessibility and validator
+            WebAccessibility webAccessibility = new WebAccessibility();
+            AccessibilityValidator validator = webAccessibility.CreateValidator(ValidationBuilder.All);
+
+            // Load the HTML document
+            using (HTMLDocument document = new HTMLDocument(inputPath))
+            {
+                ValidationResult validationResult = validator.Validate(document);
+                if (!validationResult.Success)
+                {
+                    foreach (RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == TargetTypes.HTMLElement)
+                                {
+                                    HTMLElement element = (HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    // Example attribute; adjust as needed based on the rule
+                                    string attributeValue = element.GetAttribute("alt");
+                                    Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/filter_validation_results_display_only_caption_related_warnings_focused_remediation.cs b/web-accessibility/filter_validation_results_display_only_caption_related_warnings_focused_remediation.cs
new file mode 100644
index 0000000..452c26c
--- /dev/null
+++ b/web-accessibility/filter_validation_results_display_only_caption_related_warnings_focused_remediation.cs
@@ -0,0 +1,113 @@
+// Filter validation results to display only caption‑related warnings for focused remediation efforts.
+
+using System;
+using System.IO;
+using System.Text;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare sample HTML with an accessibility issue (image without alt)
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src='image.png'></body></html>";
+            string tempHtmlPath = Path.Combine(Path.GetTempPath(), "sample.html");
+            File.WriteAllText(tempHtmlPath, htmlContent, Encoding.UTF8);
+
+            // Load the HTML document
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(tempHtmlPath))
+            {
+                // Create WebAccessibility and validator for all rules
+                Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+                Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+                // Validate the document
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                // Output validation result as string (JSON)
+                string resultJson = validationResult.SaveToString();
+                Console.WriteLine("Validation Result (JSON):");
+                Console.WriteLine(resultJson);
+                Console.WriteLine();
+
+                // If validation failed, print detailed information
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            // Print rule code and description
+                            Console.WriteLine($"{ruleResult.Rule.Code} - {ruleResult.Rule.Description}");
+
+                            // Iterate over technique errors
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                Aspose.Html.Accessibility.IError error = techResult.Error;
+                                Console.WriteLine($"  Message: {error.ErrorMessage}");
+
+                                if (error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)error.Target.Item;
+                                    Console.WriteLine($"  Element: {element.OuterHTML}");
+                                }
+                            }
+
+                            Console.WriteLine();
+                        }
+                    }
+                }
+
+                // Demonstrate accessing a specific principle and guideline (if they exist)
+                Aspose.Html.Accessibility.Principle principle = webAccessibility.Rules.GetPrinciple("Principle1");
+                if (principle != null)
+                {
+                    Aspose.Html.Accessibility.Guideline guideline = principle.GetGuideline("Guideline1");
+                    if (guideline != null)
+                    {
+                        Aspose.Html.Accessibility.AccessibilityValidator guidelineValidator =
+                            webAccessibility.CreateValidator(guideline, Aspose.Html.Accessibility.ValidationBuilder.All);
+                        Aspose.Html.Accessibility.Results.ValidationResult guidelineResult = guidelineValidator.Validate(document);
+
+                        Console.WriteLine("Guideline-specific validation completed.");
+                        Console.WriteLine($"Success: {guidelineResult.Success}");
+                    }
+                }
+
+                // Additional detailed output similar to the original snippet
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                    {
+                        if (!detail.Success)
+                        {
+                            Console.WriteLine($"{detail.Rule.Code} : {detail.Rule.Description}");
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in detail.Errors)
+                            {
+                                Aspose.Html.Accessibility.IError error = techResult.Error;
+                                Console.WriteLine(error.ErrorMessage);
+                                if (error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)error.Target.Item;
+                                    Console.WriteLine(element.OuterHTML);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Clean up temporary file
+            if (File.Exists(tempHtmlPath))
+            {
+                File.Delete(tempHtmlPath);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("An error occurred:");
+            Console.WriteLine(ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/filter_warnings_by_specific_ruleid_values_to_focus_particular_accessibility_techniques.cs b/web-accessibility/filter_warnings_by_specific_ruleid_values_to_focus_particular_accessibility_techniques.cs
new file mode 100644
index 0000000..7ea3b51
--- /dev/null
+++ b/web-accessibility/filter_warnings_by_specific_ruleid_values_to_focus_particular_accessibility_techniques.cs
@@ -0,0 +1,133 @@
+// Filter warnings by specific RuleId values to focus on particular accessibility techniques.
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare a sample HTML file
+            string htmlFilePath = Path.Combine(Path.GetTempPath(), "sample.html");
+            File.WriteAllText(htmlFilePath,
+@"<!DOCTYPE html>
+<html>
+<head><title>Sample</title></head>
+<body>
+    <img src=""image.jpg"" alt="""">
+    <h1>Welcome</h1>
+</body>
+</html>");
+
+            // 1. Basic validation and error messages
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility1 = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator1 = webAccessibility1.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (Aspose.Html.HTMLDocument document1 = new Aspose.Html.HTMLDocument(htmlFilePath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult1 = validator1.Validate(document1);
+                if (!validationResult1.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult1.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Console.WriteLine(techResult.Error.ErrorMessage);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // 2. Retrieve principle, guideline, criterion information
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility2 = new Aspose.Html.Accessibility.WebAccessibility();
+            // Example codes – replace with real codes if needed
+            Aspose.Html.Accessibility.Principle principle = webAccessibility2.Rules.GetPrinciple("1.1");
+            if (principle != null)
+            {
+                Aspose.Html.Accessibility.Guideline guideline = principle.GetGuideline("1.1.1");
+                if (guideline != null)
+                {
+                    Aspose.Html.Accessibility.Criterion criterion = guideline.GetCriterion("1.1.1.1");
+                    if (criterion != null)
+                    {
+                        Console.WriteLine("{0}:{1} - {2}", criterion.Code, criterion.Description, criterion.Level);
+                        foreach (Aspose.Html.Accessibility.IRule technique in criterion.SufficientTechniques)
+                        {
+                            Console.WriteLine("{0}:{1}", technique.Code, technique.Description);
+                        }
+                    }
+                }
+            }
+
+            // 3. Validation with element details (tag, attribute)
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility3 = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator3 = webAccessibility3.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (Aspose.Html.HTMLDocument document3 = new Aspose.Html.HTMLDocument(htmlFilePath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult3 = validator3.Validate(document3);
+                if (!validationResult3.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult3.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    string attributeValue = element.GetAttribute("alt");
+                                    Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // 4. Simple success/failure message
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility4 = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator4 = webAccessibility4.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (Aspose.Html.HTMLDocument document4 = new Aspose.Html.HTMLDocument(htmlFilePath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult4 = validator4.Validate(document4);
+                if (validationResult4.Success)
+                {
+                    Console.WriteLine("Document passed all accessibility checks.");
+                }
+                else
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult4.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                Console.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Clean up temporary file
+            if (File.Exists(htmlFilePath))
+            {
+                File.Delete(htmlFilePath);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/generate_detailed_validation_report_json_save_to_specified_output_directory.cs b/web-accessibility/generate_detailed_validation_report_json_save_to_specified_output_directory.cs
new file mode 100644
index 0000000..ad86461
--- /dev/null
+++ b/web-accessibility/generate_detailed_validation_report_json_save_to_specified_output_directory.cs
@@ -0,0 +1,57 @@
+// Generate a detailed validation report in JSON format and save it to a specified output directory.
+
+using System;
+using System.IO;
+using System.Text.Json;
+using Aspose.Html;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+using Aspose.Html.Accessibility.Saving;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputHtmlPath = "sample.html";
+            string outputDirectory = "output";
+            string jsonReportPath = Path.Combine(outputDirectory, "validation_report.json");
+
+            Directory.CreateDirectory(outputDirectory);
+
+            // Ensure a minimal sample HTML file exists
+            if (!File.Exists(inputHtmlPath))
+            {
+                File.WriteAllText(inputHtmlPath, "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello World</h1></body></html>");
+            }
+
+            using (HTMLDocument document = new HTMLDocument(inputHtmlPath))
+            {
+                AccessibilityValidator validator = new WebAccessibility().CreateValidator();
+                ValidationResult validationResult = validator.Validate(document);
+
+                using (StringWriter sw = new StringWriter())
+                {
+                    validationResult.SaveTo(sw, ValidationResultSaveFormat.XML);
+                    string xmlReport = sw.ToString();
+
+                    var reportObject = new
+                    {
+                        success = validationResult.Success,
+                        xml = xmlReport
+                    };
+
+                    string json = JsonSerializer.Serialize(reportObject, new JsonSerializerOptions { WriteIndented = true });
+                    File.WriteAllText(jsonReportPath, json);
+                }
+            }
+
+            Console.WriteLine("Validation report saved to: " + jsonReportPath);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/generate_markdown_report_from_validationresult_to_post_in_pull_request_comments.cs b/web-accessibility/generate_markdown_report_from_validationresult_to_post_in_pull_request_comments.cs
new file mode 100644
index 0000000..3769a0d
--- /dev/null
+++ b/web-accessibility/generate_markdown_report_from_validationresult_to_post_in_pull_request_comments.cs
@@ -0,0 +1,107 @@
+// Generate a markdown report from ValidationResult to post directly in pull‑request comments.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+class HeaderCaptureHandler : Aspose.Html.Net.MessageHandler
+{
+    public static List<string> CapturedHeaders = new List<string>();
+
+    public override void Invoke(Aspose.Html.Net.INetworkOperationContext context)
+    {
+        // Continue the request processing
+        Next(context);
+
+        // Capture response headers
+        foreach (object headerItem in context.Response.Headers)
+        {
+            if (headerItem != null)
+            {
+                CapturedHeaders.Add(headerItem.ToString());
+            }
+        }
+    }
+}
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // -------------------- Network request with header capture --------------------
+            Aspose.Html.Configuration configuration = new Aspose.Html.Configuration();
+            Aspose.Html.Services.INetworkService networkService = configuration.GetService<Aspose.Html.Services.INetworkService>();
+            networkService.MessageHandlers.Add(new HeaderCaptureHandler());
+
+            string url = "https://example.com";
+            string outputHtmlPath = "output.html";
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(url, configuration))
+            {
+                if (HeaderCaptureHandler.CapturedHeaders.Count > 0)
+                {
+                    string commentText = "\n" + string.Join("\n", HeaderCaptureHandler.CapturedHeaders) + "\n";
+                    var commentNode = document.CreateComment(commentText);
+                    document.InsertBefore(commentNode, document.DocumentElement);
+                }
+
+                document.Save(outputHtmlPath);
+                Console.WriteLine($"HTML saved to '{outputHtmlPath}'.");
+            }
+
+            // -------------------- Accessibility validation --------------------
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Validate the same HTML document loaded from the saved file
+            using (Aspose.Html.HTMLDocument docForValidation = new Aspose.Html.HTMLDocument(outputHtmlPath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(docForValidation);
+                if (!validationResult.Success)
+                {
+                    Console.WriteLine("Accessibility validation failed. Details:");
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                    {
+                        Console.WriteLine($"- Rule: {detail.Rule.Code}, Description: {detail.Rule.Description}, Success: {detail.Success}");
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Accessibility validation succeeded.");
+                }
+            }
+
+            // -------------------- Markdown conversion (string source) --------------------
+            string htmlContent = "<html><body><p>Hello World</p></body></html>";
+            string markdownOutputPath1 = "output.md";
+
+            Aspose.Html.Saving.MarkdownSaveOptions mdOptions1 = new Aspose.Html.Saving.MarkdownSaveOptions();
+            mdOptions1.Features = Aspose.Html.Saving.MarkdownFeatures.Link | Aspose.Html.Saving.MarkdownFeatures.AutomaticParagraph;
+
+            Aspose.Html.Converters.Converter.ConvertHTML(htmlContent, mdOptions1, markdownOutputPath1);
+            Console.WriteLine($"Markdown saved to '{markdownOutputPath1}' (from string).");
+
+            // -------------------- Markdown conversion (file source) --------------------
+            string htmlFilePath = "sample.html";
+            string markdownOutputPath2 = "sample.md";
+
+            // Ensure the sample HTML file exists
+            if (!File.Exists(htmlFilePath))
+            {
+                File.WriteAllText(htmlFilePath, htmlContent);
+            }
+
+            Aspose.Html.Saving.MarkdownSaveOptions mdOptions2 = new Aspose.Html.Saving.MarkdownSaveOptions();
+            mdOptions2.Features = Aspose.Html.Saving.MarkdownFeatures.Link | Aspose.Html.Saving.MarkdownFeatures.AutomaticParagraph;
+
+            Aspose.Html.Converters.Converter.ConvertHTML(htmlFilePath, mdOptions2, markdownOutputPath2);
+            Console.WriteLine($"Markdown saved to '{markdownOutputPath2}' (from file).");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/generate_plain_text_summary_validation_findings_review_developers.cs b/web-accessibility/generate_plain_text_summary_validation_findings_review_developers.cs
new file mode 100644
index 0000000..8a71fb6
--- /dev/null
+++ b/web-accessibility/generate_plain_text_summary_validation_findings_review_developers.cs
@@ -0,0 +1,74 @@
+// Generate a plain‑text summary of validation findings for quick review by developers.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content
+            string htmlContent = @"<!DOCTYPE html>
+<html>
+<head><title>Test</title></head>
+<body>
+    <img src='image.jpg' alt=''>
+    <a href=''>Empty link</a>
+</body>
+</html>";
+
+            // Write the sample HTML to a temporary file
+            string inputPath = Path.Combine(Path.GetTempPath(), "sample.html");
+            File.WriteAllText(inputPath, htmlContent);
+
+            // Load the HTML document
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                // Create WebAccessibility and validator
+                Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+                Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            Console.WriteLine($"Rule: {ruleResult.Rule.Code} - {ruleResult.Rule.Description}");
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                Aspose.Html.Accessibility.IError error = techResult.Error;
+                                Console.WriteLine($"  Message: {error.ErrorMessage}");
+
+                                if (error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)error.Target.Item;
+                                    Console.WriteLine($"  Element HTML: {element.OuterHTML}");
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+            }
+
+            // Clean up temporary file
+            if (File.Exists(inputPath))
+            {
+                File.Delete(inputPath);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/generate_summary_report_aggregates_total_errors_all_processed_html_documents_batch.cs b/web-accessibility/generate_summary_report_aggregates_total_errors_all_processed_html_documents_batch.cs
new file mode 100644
index 0000000..79af673
--- /dev/null
+++ b/web-accessibility/generate_summary_report_aggregates_total_errors_all_processed_html_documents_batch.cs
@@ -0,0 +1,57 @@
+// Generate a summary report that aggregates total errors across all processed HTML documents in a batch.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputDir = "input";
+            if (!System.IO.Directory.Exists(inputDir))
+            {
+                System.IO.Directory.CreateDirectory(inputDir);
+                string samplePath = System.IO.Path.Combine(inputDir, "sample1.html");
+                System.IO.File.WriteAllText(samplePath, "<html><body><p>Hello</p></body></html>");
+                string invalidPath = System.IO.Path.Combine(inputDir, "invalid.html");
+                System.IO.File.WriteAllText(invalidPath, "<html><body><p>Invalid");
+            }
+
+            int totalErrors = 0;
+
+            foreach (string htmlPath in System.IO.Directory.GetFiles(inputDir, "*.html"))
+            {
+                try
+                {
+                    Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlPath);
+                    var title = document.Title;
+                    document.Dispose();
+                }
+                catch (System.Exception ex)
+                {
+                    totalErrors++;
+                    System.Console.WriteLine($"Error processing {htmlPath}: {ex.Message}");
+                }
+            }
+
+            string missingPath = System.IO.Path.Combine(inputDir, "missing.html");
+            try
+            {
+                Aspose.Html.HTMLDocument missingDoc = new Aspose.Html.HTMLDocument(missingPath);
+                missingDoc.Dispose();
+            }
+            catch (System.Exception ex)
+            {
+                totalErrors++;
+                System.Console.WriteLine($"Error processing {missingPath}: {ex.Message}");
+            }
+
+            System.Console.WriteLine($"Total errors across all processed HTML documents: {totalErrors}");
+        }
+        catch (System.Exception ex)
+        {
+            System.Console.WriteLine($"Fatal error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/identify_video_elements_lacking_audio_description_tracks_by_filtering_validation_messages_for_description_warnings.cs b/web-accessibility/identify_video_elements_lacking_audio_description_tracks_by_filtering_validation_messages_for_description_warnings.cs
new file mode 100644
index 0000000..469ad09
--- /dev/null
+++ b/web-accessibility/identify_video_elements_lacking_audio_description_tracks_by_filtering_validation_messages_for_description_warnings.cs
@@ -0,0 +1,68 @@
+// Identify video elements lacking audio description tracks by filtering validation messages for description warnings.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Create a minimal HTML file to validate
+            string inputPath = "sample.html";
+            if (!File.Exists(inputPath))
+            {
+                File.WriteAllText(inputPath,
+@"<!DOCTYPE html>
+<html>
+<head><title>Test</title></head>
+<body>
+    <img src='image.png'>
+    <a href=''>Link without text</a>
+</body>
+</html>");
+            }
+
+            // Initialize accessibility validator
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load the document
+            using (var document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                // Perform validation
+                var validationResult = validator.Validate(document);
+
+                if (!validationResult.Success)
+                {
+                    foreach (var ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (var techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    var element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    // Attempt to retrieve a common attribute (e.g., "alt" or "href") for demonstration
+                                    string attributeValue = element.GetAttribute("alt") ?? element.GetAttribute("href") ?? "";
+                                    Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/implement_retry_mechanism_validating_remote_html_content_transient_network_failures.cs b/web-accessibility/implement_retry_mechanism_validating_remote_html_content_transient_network_failures.cs
new file mode 100644
index 0000000..064b8f4
--- /dev/null
+++ b/web-accessibility/implement_retry_mechanism_validating_remote_html_content_transient_network_failures.cs
@@ -0,0 +1,54 @@
+// Implement a retry mechanism when validating remote HTML content that may experience transient network failures.
+
+namespace AsposeHtmlRetryExample
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            try
+            {
+                // Create configuration
+                Aspose.Html.Configuration configuration = new Aspose.Html.Configuration();
+
+                // Get network service and add retry handler
+                Aspose.Html.Services.INetworkService network = configuration.GetService<Aspose.Html.Services.INetworkService>();
+                network.MessageHandlers.Add(new RetryMessageHandler(3));
+
+                // Load remote HTML document with retry mechanism
+                string url = "https://example.com";
+                using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(url, configuration))
+                {
+                    string html = ((Aspose.Html.HTMLElement)document.DocumentElement).OuterHTML;
+                    System.Console.WriteLine(html);
+                }
+            }
+            catch (System.Exception ex)
+            {
+                System.Console.WriteLine("Error: " + ex.Message);
+            }
+        }
+    }
+
+    public class RetryMessageHandler : Aspose.Html.Net.MessageHandler
+    {
+        private readonly int _maxRetries;
+
+        public RetryMessageHandler(int maxRetries)
+        {
+            _maxRetries = maxRetries;
+        }
+
+        public override void Invoke(Aspose.Html.Net.INetworkOperationContext context)
+        {
+            for (int attempt = 0; attempt <= _maxRetries; attempt++)
+            {
+                Next(context);
+                if ((int)context.Response.StatusCode < 500)
+                {
+                    break;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/incorporate_color_contrast_verification_results_into_overall_validation_summary_for_comprehensive_reporting.cs b/web-accessibility/incorporate_color_contrast_verification_results_into_overall_validation_summary_for_comprehensive_reporting.cs
new file mode 100644
index 0000000..c98de1e
--- /dev/null
+++ b/web-accessibility/incorporate_color_contrast_verification_results_into_overall_validation_summary_for_comprehensive_reporting.cs
@@ -0,0 +1,74 @@
+// Incorporate color contrast verification results into the overall validation summary for comprehensive reporting.
+
+using System;
+using System.IO;
+using System.Drawing;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare sample HTML file
+            string htmlFilePath = Path.Combine(Path.GetTempPath(), "sample.html");
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1><img src='image.png' alt='Sample Image'></body></html>";
+            File.WriteAllText(htmlFilePath, htmlContent);
+
+            // Accessibility validation
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlFilePath))
+            {
+                Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+                Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    string attributeValue = element.GetAttribute("alt");
+                                    Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // PDF conversion
+            string pdfOutputPath = Path.Combine(Path.GetTempPath(), "output.pdf");
+            Aspose.Html.Saving.PdfSaveOptions pdfOptions = new Aspose.Html.Saving.PdfSaveOptions();
+            pdfOptions.HorizontalResolution = 300;
+            pdfOptions.VerticalResolution = 300;
+            pdfOptions.BackgroundColor = System.Drawing.Color.AliceBlue;
+            pdfOptions.PageSetup.AnyPage = new Aspose.Html.Drawing.Page(new Aspose.Html.Drawing.Size(595, 842));
+
+            using (Aspose.Html.HTMLDocument pdfDoc = new Aspose.Html.HTMLDocument(htmlFilePath))
+            {
+                Aspose.Html.Converters.Converter.ConvertHTML(pdfDoc, pdfOptions, pdfOutputPath);
+            }
+
+            // XPS conversion
+            string xpsOutputPath = Path.Combine(Path.GetTempPath(), "output.xps");
+            Aspose.Html.Saving.XpsSaveOptions xpsOptions = new Aspose.Html.Saving.XpsSaveOptions();
+
+            using (Aspose.Html.HTMLDocument xpsDoc = new Aspose.Html.HTMLDocument(htmlFilePath))
+            {
+                Aspose.Html.Converters.Converter.ConvertHTML(xpsDoc, xpsOptions, xpsOutputPath);
+            }
+
+            Console.WriteLine("Processing completed successfully.");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/initialize_htmldocument_from_file_path_and_validate_using_default_validator.cs b/web-accessibility/initialize_htmldocument_from_file_path_and_validate_using_default_validator.cs
new file mode 100644
index 0000000..07be699
--- /dev/null
+++ b/web-accessibility/initialize_htmldocument_from_file_path_and_validate_using_default_validator.cs
@@ -0,0 +1,54 @@
+// Initialize an HTMLDocument from a file path and validate it using the default validator.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1><p>This is a sample.</p></body></html>";
+
+            // Load HTML document from string
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, ""))
+            {
+                // Perform accessibility validation
+                Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+                Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator();
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                // Save validation result to XML string and output
+                using (StringWriter sw = new StringWriter())
+                {
+                    validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                    string xmlResult = sw.ToString();
+                    Console.WriteLine("Accessibility Validation Result (XML):");
+                    Console.WriteLine(xmlResult);
+                }
+
+                // Output the document's outer HTML
+                string outerHtml = document.DocumentElement.OuterHTML;
+                Console.WriteLine("\nDocument OuterHTML:");
+                Console.WriteLine(outerHtml);
+
+                // Output the body text content
+                Aspose.Html.HTMLElement body = document.Body;
+                string bodyText = body.TextContent;
+                Console.WriteLine("\nBody TextContent:");
+                Console.WriteLine(bodyText);
+
+                // Save the document to a file
+                string outputPath = "output.html";
+                document.Save(outputPath);
+                Console.WriteLine($"\nDocument saved to {outputPath}");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/inject_accessibilityvalidator_dependency_injection_enable_flexible_configuration_aspnet_core_applications.cs b/web-accessibility/inject_accessibilityvalidator_dependency_injection_enable_flexible_configuration_aspnet_core_applications.cs
new file mode 100644
index 0000000..e10cdb0
--- /dev/null
+++ b/web-accessibility/inject_accessibilityvalidator_dependency_injection_enable_flexible_configuration_aspnet_core_applications.cs
@@ -0,0 +1,76 @@
+// Inject AccessibilityValidator via dependency injection to enable flexible configuration in ASP.NET Core applications.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare a minimal HTML file for validation
+            string htmlFilePath = Path.Combine(Path.GetTempPath(), "sample.html");
+            File.WriteAllText(htmlFilePath, "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>");
+
+            // First validation: all rules, print success or all error messages
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility1 = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator1 = webAccessibility1.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (Aspose.Html.HTMLDocument document1 = new Aspose.Html.HTMLDocument(htmlFilePath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult1 = validator1.Validate(document1);
+                if (validationResult1.Success)
+                {
+                    Console.WriteLine("Document passed all accessibility checks.");
+                }
+                else
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult1.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                Console.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Second validation: print only errors targeting HTML elements
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility2 = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator2 = webAccessibility2.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (Aspose.Html.HTMLDocument document2 = new Aspose.Html.HTMLDocument(htmlFilePath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult2 = validator2.Validate(document2);
+                if (!validationResult2.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult2.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Console.WriteLine(techResult.Error.ErrorMessage);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Clean up temporary file
+            if (File.Exists(htmlFilePath))
+            {
+                File.Delete(htmlFilePath);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/instantiate_accessibilityvalidator_using_createvalidator_before_loading_any_html_document.cs b/web-accessibility/instantiate_accessibilityvalidator_using_createvalidator_before_loading_any_html_document.cs
new file mode 100644
index 0000000..ce2a7d0
--- /dev/null
+++ b/web-accessibility/instantiate_accessibilityvalidator_using_createvalidator_before_loading_any_html_document.cs
@@ -0,0 +1,76 @@
+// Instantiate an AccessibilityValidator using CreateValidator before loading any HTML document.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare a minimal HTML file with an accessibility issue (missing alt attribute on img)
+            string htmlContent = @"<!DOCTYPE html>
+<html>
+<head><title>Accessibility Test</title></head>
+<body>
+    <img src='image.png'>
+</body>
+</html>";
+            string inputFilePath = Path.Combine(Directory.GetCurrentDirectory(), "sample.html");
+            File.WriteAllText(inputFilePath, htmlContent);
+
+            // Initialize WebAccessibility and create a validator for all rules
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load the HTML document
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputFilePath))
+            {
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (validationResult.Success)
+                {
+                    Console.WriteLine("Document passed all accessibility checks.");
+                }
+                else
+                {
+                    Console.WriteLine("Accessibility validation failed. Details:");
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                // If the error target is an HTML element, output element details
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    string attributeValue = element.GetAttribute("alt"); // example attribute
+                                    Console.WriteLine($"Tag: {tagName}, Alt attribute: {attributeValue ?? "null"}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                                else
+                                {
+                                    // Non-element target, just output the message
+                                    Console.WriteLine($"Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Clean up the temporary file
+            if (File.Exists(inputFilePath))
+            {
+                File.Delete(inputFilePath);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/integrate_accessibility_validation_into_aspose_html_workflows_multimedia_processing_pipeline.cs b/web-accessibility/integrate_accessibility_validation_into_aspose_html_workflows_multimedia_processing_pipeline.cs
new file mode 100644
index 0000000..25d87d3
--- /dev/null
+++ b/web-accessibility/integrate_accessibility_validation_into_aspose_html_workflows_multimedia_processing_pipeline.cs
@@ -0,0 +1,64 @@
+// Integrate accessibility validation into Aspose.HTML workflows as part of the multimedia processing pipeline.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string htmlFilePath = "sample.html";
+            if (!File.Exists(htmlFilePath))
+            {
+                string sampleHtml = @"<!DOCTYPE html>
+<html>
+<head><title>Sample</title></head>
+<body>
+<video controls>
+    <source src=""video.mp4"" type=""video/mp4"">
+    <track src=""captions.vtt"" kind=""captions"" srclang=""en"" label=""English"">
+</video>
+</body>
+</html>";
+                File.WriteAllText(htmlFilePath, sampleHtml);
+            }
+
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlFilePath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    string attributeValue = element.GetAttribute("src");
+                                    Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Accessibility validation succeeded with no errors.");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/integrate_validation_step_into_ci_cd_pipeline_using_command_line_invocation_validator.cs b/web-accessibility/integrate_validation_step_into_ci_cd_pipeline_using_command_line_invocation_validator.cs
new file mode 100644
index 0000000..dd28bed
--- /dev/null
+++ b/web-accessibility/integrate_validation_step_into_ci_cd_pipeline_using_command_line_invocation_validator.cs
@@ -0,0 +1,59 @@
+// Integrate the validation step into a CI/CD pipeline using a command‑line invocation of the validator.
+
+using System;
+using System.IO;
+using System.Text;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello, world!</h1></body></html>";
+
+            // Load the HTML document from the string
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent))
+            {
+                // Create a WebAccessibility instance
+                Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+                // Create a validator (default validation rules)
+                Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator();
+
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                // Save validation result as XML to a string and output it
+                using (StringWriter sw = new StringWriter())
+                {
+                    validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                    Console.WriteLine("Validation Result (XML):");
+                    Console.WriteLine(sw.ToString());
+                }
+
+                // Check success and output details if any failures
+                if (!validationResult.Success)
+                {
+                    Console.WriteLine("Validation failed. Details:");
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                    {
+                        Console.WriteLine($"Rule Code: {detail.Rule.Code}");
+                        Console.WriteLine($"Description: {detail.Rule.Description}");
+                        Console.WriteLine($"Success: {detail.Success}");
+                        Console.WriteLine();
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Validation succeeded.");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/integrate_validation_step_into_github_actions_workflow_to_automatically_test_pull_requests.cs b/web-accessibility/integrate_validation_step_into_github_actions_workflow_to_automatically_test_pull_requests.cs
new file mode 100644
index 0000000..21722f9
--- /dev/null
+++ b/web-accessibility/integrate_validation_step_into_github_actions_workflow_to_automatically_test_pull_requests.cs
@@ -0,0 +1,111 @@
+// Integrate the validation step into a GitHub Actions workflow to automatically test pull requests.
+
+using System;
+using System.Collections.Generic;
+using System.Net;
+using Aspose.Html;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+using Aspose.Html.Net;
+using Aspose.Html.Services;
+
+class AuthHandler : Aspose.Html.Net.MessageHandler
+{
+    public override void Invoke(Aspose.Html.Net.INetworkOperationContext context)
+    {
+        // Simple auth check: require "Authorization" header
+        if (string.IsNullOrEmpty(context.Request.Headers["Authorization"]))
+        {
+            context.Response.StatusCode = HttpStatusCode.Unauthorized;
+            return;
+        }
+        Next(context);
+    }
+}
+
+class LogHandler : Aspose.Html.Net.MessageHandler
+{
+    private readonly List<string> _logs = new List<string>();
+
+    public override void Invoke(Aspose.Html.Net.INetworkOperationContext context)
+    {
+        Next(context);
+        _logs.Add($"URL: {context.Request.RequestUri} | Status: {context.Response.StatusCode}");
+    }
+
+    public IReadOnlyList<string> Logs => _logs;
+}
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Configuration with custom network handlers
+            var configuration = new Aspose.Html.Configuration();
+            var network = configuration.GetService<Aspose.Html.Services.INetworkService>();
+            network.MessageHandlers.Add(new AuthHandler());
+            var logger = new LogHandler();
+            network.MessageHandlers.Add(logger);
+
+            // Sample HTML content
+            string htmlContent = @"<!DOCTYPE html>
+<html>
+<head><title>Sample</title></head>
+<body>
+    <h1>Hello, Aspose.HTML!</h1>
+    <p>This is a test document.</p>
+</body>
+</html>";
+
+            // Load document using the configuration (handlers will be active)
+            using (var document = new Aspose.Html.HTMLDocument(htmlContent, configuration))
+            {
+                // Accessibility validation (full set of rules)
+                var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+                var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+                ValidationResult validationResult = validator.Validate(document);
+
+                if (!validationResult.Success)
+                {
+                    Console.WriteLine("Accessibility validation failed. Details:");
+                    foreach (RuleValidationResult detail in validationResult.Details)
+                    {
+                        Console.WriteLine($"Rule: {detail.Rule.Code} - {detail.Rule.Description} - Success: {detail.Success}");
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Accessibility validation succeeded.");
+                }
+
+                // Guideline‑specific validation example
+                var principle = webAccessibility.Rules.GetPrinciple("WCAG2.0");
+                var guideline = principle.GetGuideline("1.1.1");
+                var guidelineValidator = webAccessibility.CreateValidator(guideline, Aspose.Html.Accessibility.ValidationBuilder.All);
+                ValidationResult guidelineResult = guidelineValidator.Validate(document);
+
+                if (!guidelineResult.Success)
+                {
+                    Console.WriteLine("Guideline validation failed.");
+                }
+                else
+                {
+                    Console.WriteLine("Guideline validation succeeded.");
+                }
+            }
+
+            // Output logged network activity
+            Console.WriteLine("\nNetwork activity log:");
+            foreach (string entry in logger.Logs)
+            {
+                Console.WriteLine(entry);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/iterate_accessibility_rules_advisory_techniques_list_improvement_suggestions_each_identified_issue.cs b/web-accessibility/iterate_accessibility_rules_advisory_techniques_list_improvement_suggestions_each_identified_issue.cs
new file mode 100644
index 0000000..75a75d0
--- /dev/null
+++ b/web-accessibility/iterate_accessibility_rules_advisory_techniques_list_improvement_suggestions_each_identified_issue.cs
@@ -0,0 +1,134 @@
+// Iterate AccessibilityRules.AdvisoryTechniques to list improvement suggestions for each identified issue.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare a sample HTML file
+            string htmlPath = "sample.html";
+            File.WriteAllText(htmlPath,
+                "<!DOCTYPE html><html><head><title>Test</title></head>" +
+                "<body><img src=\"image.png\"><p>Hello World</p></body></html>");
+
+            // 1. Detailed validation with element info
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility1 = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator1 = webAccessibility1.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (Aspose.Html.HTMLDocument document1 = new Aspose.Html.HTMLDocument(htmlPath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult1 = validator1.Validate(document1);
+                if (!validationResult1.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult1.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    string attributeValue = element.GetAttribute("alt");
+                                    Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // 2. Simple error messages
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility2 = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator2 = webAccessibility2.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (Aspose.Html.HTMLDocument document2 = new Aspose.Html.HTMLDocument(htmlPath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult2 = validator2.Validate(document2);
+                if (!validationResult2.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult2.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                Console.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // 3. Success / failure output
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility3 = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator3 = webAccessibility3.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (Aspose.Html.HTMLDocument document3 = new Aspose.Html.HTMLDocument(htmlPath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult3 = validator3.Validate(document3);
+                if (validationResult3.Success)
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+                else
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult3.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                Console.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // 4. Validation for a specific guideline
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility4 = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.Principle principle4 = webAccessibility4.Rules.GetPrinciple("Perceivable");
+            Aspose.Html.Accessibility.Guideline guideline4 = principle4.GetGuideline("Text Alternatives");
+            Aspose.Html.Accessibility.AccessibilityValidator validator4 = webAccessibility4.CreateValidator(guideline4, Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (Aspose.Html.HTMLDocument document4 = new Aspose.Html.HTMLDocument(htmlPath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult4 = validator4.Validate(document4);
+                foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult4.Details)
+                {
+                    if (!ruleResult.Success)
+                    {
+                        foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                        {
+                            Console.WriteLine(techResult.Error.ErrorMessage);
+                        }
+                    }
+                }
+            }
+
+            // 5. List criterion and its sufficient techniques
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility5 = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.Principle principle5 = webAccessibility5.Rules.GetPrinciple("Perceivable");
+            Aspose.Html.Accessibility.Guideline guideline5 = principle5.GetGuideline("Text Alternatives");
+            Aspose.Html.Accessibility.Criterion criterion5 = guideline5.GetCriterion("1.1.1");
+            if (criterion5 != null)
+            {
+                Console.WriteLine($"{criterion5.Code}:{criterion5.Description} - {criterion5.Level}");
+                foreach (Aspose.Html.Accessibility.IRule technique in criterion5.SufficientTechniques)
+                {
+                    Console.WriteLine($"{technique.Code}:{technique.Description}");
+                }
+            }
+            else
+            {
+                Console.WriteLine("Criterion not found.");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/iterate_through_validationresult_details_to_log_each_rule_identifier_and_its_pass_or_fail_status.cs b/web-accessibility/iterate_through_validationresult_details_to_log_each_rule_identifier_and_its_pass_or_fail_status.cs
new file mode 100644
index 0000000..1a4f953
--- /dev/null
+++ b/web-accessibility/iterate_through_validationresult_details_to_log_each_rule_identifier_and_its_pass_or_fail_status.cs
@@ -0,0 +1,54 @@
+// Iterate through ValidationResult.Details to log each rule identifier and its pass or fail status.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content
+            string html = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>";
+
+            // Create a temporary HTML file
+            string tempPath = Path.Combine(Path.GetTempPath(), "sample.html");
+            File.WriteAllText(tempPath, html);
+
+            // Initialize WebAccessibility and validator
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load the HTML document
+            var document = new Aspose.Html.HTMLDocument(tempPath);
+
+            // Perform validation
+            var validationResult = validator.Validate(document);
+
+            // Output results
+            if (!validationResult.Success)
+            {
+                Console.WriteLine("Accessibility validation failed. Details:");
+                foreach (var detail in validationResult.Details)
+                {
+                    Console.WriteLine($"Rule Code: {detail.Rule.Code}");
+                    Console.WriteLine($"Description: {detail.Rule.Description}");
+                    Console.WriteLine($"Success: {detail.Success}");
+                    Console.WriteLine();
+                }
+            }
+            else
+            {
+                Console.WriteLine("Accessibility validation succeeded.");
+            }
+
+            // Clean up
+            document.Dispose();
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/load_html_content_from_string_into_validator_for_in_memory_validation.cs b/web-accessibility/load_html_content_from_string_into_validator_for_in_memory_validation.cs
new file mode 100644
index 0000000..9fde31d
--- /dev/null
+++ b/web-accessibility/load_html_content_from_string_into_validator_for_in_memory_validation.cs
@@ -0,0 +1,28 @@
+// Load HTML content from a string variable into the validator for in‑memory validation scenarios.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Welcome</h1></body></html>";
+            string baseUri = "http://example.com";
+
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, baseUri))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                Console.WriteLine("Validation completed.");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/load_html_content_string_create_document_accessibility_validation.cs b/web-accessibility/load_html_content_string_create_document_accessibility_validation.cs
new file mode 100644
index 0000000..ba585d4
--- /dev/null
+++ b/web-accessibility/load_html_content_string_create_document_accessibility_validation.cs
@@ -0,0 +1,54 @@
+// Load HTML content from a string, create a document object, and run accessibility validation.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><img src='image.png'></body></html>";
+            string tempPath = Path.Combine(Path.GetTempPath(), "sample.html");
+            File.WriteAllText(tempPath, htmlContent);
+
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(tempPath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (validationResult.Success)
+                {
+                    Console.WriteLine("Accessibility validation passed.");
+                }
+                else
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                Console.WriteLine(techResult.Error.ErrorMessage);
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    Console.WriteLine("Offending element: " + element.OuterHTML);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            File.Delete(tempPath);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/load_html_file_from_disk_into_validator_with_file_path_argument.cs b/web-accessibility/load_html_file_from_disk_into_validator_with_file_path_argument.cs
new file mode 100644
index 0000000..7458141
--- /dev/null
+++ b/web-accessibility/load_html_file_from_disk_into_validator_with_file_path_argument.cs
@@ -0,0 +1,25 @@
+// Load an HTML file from disk into the validator using the Load method with a file path argument.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputPath = "sample.html";
+            if (!System.IO.File.Exists(inputPath))
+            {
+                System.IO.File.WriteAllText(inputPath, "<html><body><p>Hello World</p></body></html>");
+            }
+
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath);
+            System.Console.WriteLine("HTML document loaded successfully.");
+        }
+        catch (System.Exception ex)
+        {
+            System.Console.WriteLine(ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/load_html_file_from_local_path_into_validator_for_wcag_analysis.cs b/web-accessibility/load_html_file_from_local_path_into_validator_for_wcag_analysis.cs
new file mode 100644
index 0000000..2c9b620
--- /dev/null
+++ b/web-accessibility/load_html_file_from_local_path_into_validator_for_wcag_analysis.cs
@@ -0,0 +1,47 @@
+// Load an HTML file from a local path into the validator for WCAG analysis.
+
+using System;
+using System.Drawing;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>";
+
+            // Initialize WebAccessibility and create a validator for all rules
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load the HTML document from the string literal
+            var document = new Aspose.Html.HTMLDocument(htmlContent);
+
+            // Perform validation
+            Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+            // Output validation results
+            if (validationResult.Success)
+            {
+                Console.WriteLine("Accessibility validation succeeded. No issues found.");
+            }
+            else
+            {
+                Console.WriteLine("Accessibility validation failed. Details:");
+                foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                {
+                    Console.WriteLine($"Rule Code: {detail.Rule.Code}");
+                    Console.WriteLine($"Description: {detail.Rule.Description}");
+                    Console.WriteLine($"Success: {detail.Success}");
+                    Console.WriteLine(new string('-', 40));
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/load_html_from_stream_object_into_validator_support_network_memory_sources.cs b/web-accessibility/load_html_from_stream_object_into_validator_support_network_memory_sources.cs
new file mode 100644
index 0000000..7720678
--- /dev/null
+++ b/web-accessibility/load_html_from_stream_object_into_validator_support_network_memory_sources.cs
@@ -0,0 +1,78 @@
+// Load HTML from a Stream object into the validator to support network or memory‑based sources.
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+
+class MemoryStreamProvider : Aspose.Html.IO.ICreateStreamProvider, IDisposable
+{
+    private readonly List<MemoryStream> _streams = new List<MemoryStream>();
+
+    public Stream GetStream(string name, string extension)
+    {
+        var ms = new MemoryStream();
+        _streams.Add(ms);
+        return ms;
+    }
+
+    public Stream GetStream(string name, string extension, int page)
+    {
+        var ms = new MemoryStream();
+        _streams.Add(ms);
+        return ms;
+    }
+
+    public void ReleaseStream(Stream stream)
+    {
+        stream.Flush();
+    }
+
+    public IReadOnlyList<MemoryStream> Streams => _streams;
+
+    public void Dispose()
+    {
+        foreach (var s in _streams)
+            s.Dispose();
+    }
+}
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string html = "<html><body><h1>Hello, Aspose.HTML!</h1></body></html>";
+            string baseUrl = "";
+
+            using (var document = new Aspose.Html.HTMLDocument(html, baseUrl))
+            {
+                var options = new Aspose.Html.Saving.PdfSaveOptions();
+
+                using (var provider = new MemoryStreamProvider())
+                {
+                    Aspose.Html.Converters.Converter.ConvertHTML(document, options, provider);
+
+                    if (provider.Streams.Count > 0)
+                    {
+                        var pdfStream = provider.Streams[0];
+                        pdfStream.Position = 0;
+                        byte[] pdfBytes = pdfStream.ToArray();
+
+                        string outputPath = Path.Combine(Directory.GetCurrentDirectory(), "output.pdf");
+                        File.WriteAllBytes(outputPath, pdfBytes);
+                        Console.WriteLine($"PDF saved to {outputPath}, size {pdfBytes.Length} bytes.");
+                    }
+                    else
+                    {
+                        Console.WriteLine("No PDF stream was generated.");
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/log_validation_messages_to_file_for_further_analysis_and_troubleshooting_developers.cs b/web-accessibility/log_validation_messages_to_file_for_further_analysis_and_troubleshooting_developers.cs
new file mode 100644
index 0000000..a345a36
--- /dev/null
+++ b/web-accessibility/log_validation_messages_to_file_for_further_analysis_and_troubleshooting_developers.cs
@@ -0,0 +1,55 @@
+// Log all validation messages to a file for further analysis and troubleshooting by developers.
+
+using System;
+using System.IO;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+using Aspose.Html;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare a minimal HTML file if it does not exist
+            string inputPath = "sample.html";
+            if (!File.Exists(inputPath))
+            {
+                File.WriteAllText(inputPath, "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello World</h1></body></html>");
+            }
+
+            // Initialize accessibility validator
+            WebAccessibility webAccessibility = new WebAccessibility();
+            AccessibilityValidator validator = webAccessibility.CreateValidator();
+
+            // Load the HTML document
+            using (HTMLDocument document = new HTMLDocument(inputPath))
+            {
+                // Perform validation
+                ValidationResult result = validator.Validate(document);
+
+                // Log validation messages to a file
+                string logPath = "validation_log.txt";
+                using (StreamWriter writer = new StreamWriter(logPath, true))
+                {
+                    writer.WriteLine($"Validation Success: {result.Success}");
+                    writer.WriteLine("Details:");
+                    foreach (RuleValidationResult detail in result.Details)
+                    {
+                        writer.WriteLine($"Rule Code: {detail.Rule.Code}");
+                        writer.WriteLine($"Description: {detail.Rule.Description}");
+                        writer.WriteLine($"Passed: {detail.Success}");
+                        writer.WriteLine(new string('-', 40));
+                    }
+                }
+            }
+
+            Console.WriteLine("Validation completed. Messages logged to validation_log.txt");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/modify_video_elements_include_keyboard_focusable_controls_add_tabindex_attributes_needed.cs b/web-accessibility/modify_video_elements_include_keyboard_focusable_controls_add_tabindex_attributes_needed.cs
new file mode 100644
index 0000000..4a5030c
--- /dev/null
+++ b/web-accessibility/modify_video_elements_include_keyboard_focusable_controls_add_tabindex_attributes_needed.cs
@@ -0,0 +1,31 @@
+// Modify video elements to include keyboard‑focusable controls by adding tabindex attributes where needed.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputPath = "input.html";
+            string outputPath = "output.html";
+
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath);
+
+            var videoElements = document.QuerySelectorAll("video");
+            for (int i = 0; i < videoElements.Length; i++)
+            {
+                Aspose.Html.Dom.Element element = (Aspose.Html.Dom.Element)videoElements[i];
+                element.SetAttribute("tabindex", "0");
+            }
+
+            document.Save(outputPath);
+            Console.WriteLine("Video elements have been updated with tabindex attributes.");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/prioritize_remediation_tasks_severity_levels_advisory_technique_impact_scores.cs b/web-accessibility/prioritize_remediation_tasks_severity_levels_advisory_technique_impact_scores.cs
new file mode 100644
index 0000000..bff7586
--- /dev/null
+++ b/web-accessibility/prioritize_remediation_tasks_severity_levels_advisory_technique_impact_scores.cs
@@ -0,0 +1,89 @@
+// Prioritize remediation tasks based on severity levels and advisory technique impact scores.
+
+using System;
+using System.IO;
+using System.Threading;
+
+class RetryMessageHandler : Aspose.Html.Net.MessageHandler
+{
+    private readonly int _maxRetries;
+
+    public RetryMessageHandler(int maxRetries)
+    {
+        _maxRetries = maxRetries;
+    }
+
+    public override void Invoke(Aspose.Html.Net.INetworkOperationContext context)
+    {
+        for (int attempt = 0; attempt <= _maxRetries; attempt++)
+        {
+            base.Next(context);
+            if ((int)context.Response.StatusCode < 500)
+                break;
+        }
+    }
+}
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare configuration and add retry handler
+            Aspose.Html.Configuration configuration = new Aspose.Html.Configuration();
+            Aspose.Html.Services.INetworkService network = configuration.GetService<Aspose.Html.Services.INetworkService>();
+            network.MessageHandlers.Add(new RetryMessageHandler(3));
+
+            // Define input and output paths
+            string inputPath = "sample.mht";
+            string outputPath = "output.pdf";
+
+            // Ensure a minimal MHTML file exists
+            if (!File.Exists(inputPath))
+            {
+                File.WriteAllText(inputPath, "<html><body><h1>Sample MHTML</h1></body></html>");
+            }
+
+            // Perform conversion with retry
+            ConvertMhtmlToPdfWithRetry(inputPath, outputPath, 3);
+            Console.WriteLine("Conversion completed successfully.");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+
+    static void ConvertMhtmlToPdfWithRetry(string inputPath, string outputPath, int maxAttempts)
+    {
+        Exception lastException = null;
+        for (int attempt = 1; attempt <= maxAttempts; attempt++)
+        {
+            try
+            {
+                using (FileStream stream = File.OpenRead(inputPath))
+                {
+                    Aspose.Html.Saving.PdfSaveOptions options = new Aspose.Html.Saving.PdfSaveOptions();
+                    Aspose.Html.Converters.Converter.ConvertMHTML(stream, options, outputPath);
+                }
+                // Success, exit method
+                return;
+            }
+            catch (IOException ioEx)
+            {
+                lastException = ioEx;
+            }
+            catch (UnauthorizedAccessException uaEx)
+            {
+                lastException = uaEx;
+            }
+
+            // Wait before next retry
+            Thread.Sleep(1000);
+        }
+
+        // All attempts failed
+        throw lastException ?? new Exception("Conversion failed without captured exception.");
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/process_batch_html_files_in_folder_validating_each_file_sequentially_aggregating_results.cs b/web-accessibility/process_batch_html_files_in_folder_validating_each_file_sequentially_aggregating_results.cs
new file mode 100644
index 0000000..e079b3f
--- /dev/null
+++ b/web-accessibility/process_batch_html_files_in_folder_validating_each_file_sequentially_aggregating_results.cs
@@ -0,0 +1,44 @@
+// Process a batch of HTML files in a folder, validating each file sequentially and aggregating results.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputFolder = "InputHtml";
+            string outputFolder = "OutputImages";
+
+            Directory.CreateDirectory(inputFolder);
+            Directory.CreateDirectory(outputFolder);
+
+            // Create a minimal sample HTML file if none exist
+            string sampleHtmlPath = Path.Combine(inputFolder, "sample.html");
+            if (!File.Exists(sampleHtmlPath))
+            {
+                File.WriteAllText(sampleHtmlPath, "<html><body><h1>Hello Aspose HTML</h1></body></html>");
+            }
+
+            foreach (string htmlPath in Directory.GetFiles(inputFolder, "*.html"))
+            {
+                using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlPath))
+                {
+                    Aspose.Html.Saving.ImageSaveOptions options = new Aspose.Html.Saving.ImageSaveOptions(
+                        Aspose.Html.Rendering.Image.ImageFormat.Jpeg);
+                    string outputPath = Path.Combine(outputFolder,
+                        Path.GetFileNameWithoutExtension(htmlPath) + ".jpg");
+                    Aspose.Html.Converters.Converter.ConvertHTML(document, options, outputPath);
+                }
+            }
+
+            Console.WriteLine("Conversion completed.");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/process_html_files_parallel_using_task_parallel_library_improve_validation_throughput_large_projects.cs b/web-accessibility/process_html_files_parallel_using_task_parallel_library_improve_validation_throughput_large_projects.cs
new file mode 100644
index 0000000..8b89ceb
--- /dev/null
+++ b/web-accessibility/process_html_files_parallel_using_task_parallel_library_improve_validation_throughput_large_projects.cs
@@ -0,0 +1,151 @@
+// Process HTML files in parallel using Task Parallel Library to improve validation throughput for large projects.
+
+using System;
+using System.IO;
+using System.IO.Compression;
+using System.Drawing;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare folders
+            string inputFolder = "InputHtml";
+            string outputFolder = "Output";
+            Directory.CreateDirectory(inputFolder);
+            Directory.CreateDirectory(outputFolder);
+
+            // Create a sample HTML file if none exist
+            string[] existingHtml = Directory.GetFiles(inputFolder, "*.html");
+            if (existingHtml.Length == 0)
+            {
+                string samplePath = Path.Combine(inputFolder, "sample.html");
+                File.WriteAllText(samplePath, "<html><body><h1>Hello Aspose.HTML</h1></body></html>");
+            }
+
+            // 1. Convert each HTML file to JPEG image
+            foreach (string htmlPath in Directory.GetFiles(inputFolder, "*.html"))
+            {
+                using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlPath))
+                {
+                    Aspose.Html.Saving.ImageSaveOptions options = new Aspose.Html.Saving.ImageSaveOptions(
+                        Aspose.Html.Rendering.Image.ImageFormat.Jpeg);
+                    string outputPath = Path.Combine(outputFolder,
+                        Path.GetFileNameWithoutExtension(htmlPath) + ".jpg");
+                    Aspose.Html.Converters.Converter.ConvertHTML(document, options, outputPath);
+                }
+            }
+
+            // 2. Merge two HTML files into one document
+            string[] inputFiles = new string[]
+            {
+                Path.Combine(inputFolder, "sample.html"),
+                Path.Combine(inputFolder, "sample2.html")
+            };
+            // Ensure second sample exists
+            if (!File.Exists(inputFiles[1]))
+            {
+                File.WriteAllText(inputFiles[1], "<html><body><p>Second file content.</p></body></html>");
+            }
+
+            Aspose.Html.HTMLDocument mergedDocument = new Aspose.Html.HTMLDocument(
+                "<html><head></head><body></body></html>");
+            foreach (string filePath in inputFiles)
+            {
+                if (!File.Exists(filePath))
+                    continue;
+
+                using (Aspose.Html.HTMLDocument sourceDocument = new Aspose.Html.HTMLDocument(filePath))
+                {
+                    Aspose.Html.HTMLElement container = (Aspose.Html.HTMLElement)mergedDocument.CreateElement("div");
+                    container.InnerHTML = sourceDocument.Body != null ? sourceDocument.Body.InnerHTML : string.Empty;
+                    mergedDocument.Body.AppendChild(container);
+                }
+            }
+            string mergedPath = Path.Combine(outputFolder, "merged.html");
+            mergedDocument.Save(mergedPath);
+            mergedDocument.Dispose();
+
+            // 3. Convert HTML files to PDF with network logging
+            foreach (string htmlPath in Directory.GetFiles(inputFolder, "*.html"))
+            {
+                Aspose.Html.Configuration configuration = new Aspose.Html.Configuration();
+                Aspose.Html.Services.INetworkService network = configuration.GetService<Aspose.Html.Services.INetworkService>();
+                network.MessageHandlers.Add(new LogHandler());
+
+                using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlPath, configuration))
+                {
+                    string pdfPath = Path.ChangeExtension(htmlPath, ".pdf");
+                    Aspose.Html.Saving.PdfSaveOptions options = new Aspose.Html.Saving.PdfSaveOptions();
+                    Aspose.Html.Converters.Converter.ConvertHTML(document, options, pdfPath);
+                }
+            }
+
+            // 4. Extract HTML files from a zip archive (if zip exists)
+            string zipPath = "sample.zip";
+            string extractDir = Path.Combine(Path.GetTempPath(), "AsposeHtmlExtract");
+            Directory.CreateDirectory(extractDir);
+            if (File.Exists(zipPath))
+            {
+                using (FileStream zipStream = File.OpenRead(zipPath))
+                using (ZipArchive archive = new ZipArchive(zipStream, ZipArchiveMode.Read))
+                {
+                    foreach (ZipArchiveEntry entry in archive.Entries)
+                    {
+                        if (entry.FullName.EndsWith(".html", StringComparison.OrdinalIgnoreCase))
+                        {
+                            string entryPath = Path.Combine(extractDir, entry.FullName);
+                            Directory.CreateDirectory(Path.GetDirectoryName(entryPath));
+                            entry.ExtractToFile(entryPath, true);
+                        }
+                    }
+                }
+            }
+
+            // 5. Convert extracted HTML to PDF with timeout handling
+            Aspose.Html.Configuration configWithTimeout = new Aspose.Html.Configuration();
+            Aspose.Html.Services.INetworkService netWithTimeout = configWithTimeout.GetService<Aspose.Html.Services.INetworkService>();
+            netWithTimeout.MessageHandlers.Add(new TimeoutHandler());
+
+            string[] extractedHtml = Directory.GetFiles(extractDir, "*.html", SearchOption.AllDirectories);
+            if (extractedHtml.Length > 0)
+            {
+                string htmlPath = extractedHtml[0];
+                using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlPath, configWithTimeout))
+                {
+                    string pdfOut = Path.Combine(outputFolder, "extracted.pdf");
+                    Aspose.Html.Rendering.Pdf.PdfDevice device = new Aspose.Html.Rendering.Pdf.PdfDevice(pdfOut);
+                    document.RenderTo(device);
+                }
+            }
+
+            Console.WriteLine("Processing completed successfully.");
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
+
+// Network request logger
+class LogHandler : Aspose.Html.Net.MessageHandler
+{
+    public override void Invoke(Aspose.Html.Net.INetworkOperationContext context)
+    {
+        Next(context);
+        Console.WriteLine($"{context.Request.RequestUri} | {context.Response.StatusCode}");
+    }
+}
+
+// Network timeout setter
+class TimeoutHandler : Aspose.Html.Net.MessageHandler
+{
+    public override void Invoke(Aspose.Html.Net.INetworkOperationContext context)
+    {
+        context.Request.Timeout = TimeSpan.FromSeconds(30);
+        Next(context);
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/process_html_folder_validate_each_output_individual_json_reports_to_target_directory.cs b/web-accessibility/process_html_folder_validate_each_output_individual_json_reports_to_target_directory.cs
new file mode 100644
index 0000000..6125faf
--- /dev/null
+++ b/web-accessibility/process_html_folder_validate_each_output_individual_json_reports_to_target_directory.cs
@@ -0,0 +1,79 @@
+// Process a folder of HTML files, validate each, and output individual JSON reports to a target directory.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare input and output folders
+            string inputFolder = Path.Combine(Directory.GetCurrentDirectory(), "InputHtml");
+            string outputFolder = Path.Combine(Directory.GetCurrentDirectory(), "OutputImages");
+            Directory.CreateDirectory(inputFolder);
+            Directory.CreateDirectory(outputFolder);
+
+            // Create a sample HTML file if none exist
+            string sampleHtmlPath = Path.Combine(inputFolder, "sample.html");
+            if (!File.Exists(sampleHtmlPath))
+            {
+                File.WriteAllText(sampleHtmlPath, "<html><body><h1>Hello Aspose</h1></body></html>");
+            }
+
+            // Convert each HTML file to JPEG
+            foreach (string htmlPath in Directory.GetFiles(inputFolder, "*.html"))
+            {
+                using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlPath))
+                {
+                    Aspose.Html.Saving.ImageSaveOptions options = new Aspose.Html.Saving.ImageSaveOptions(Aspose.Html.Rendering.Image.ImageFormat.Jpeg);
+                    string outputPath = Path.Combine(outputFolder, Path.GetFileNameWithoutExtension(htmlPath) + ".jpg");
+                    Aspose.Html.Converters.Converter.ConvertHTML(document, options, outputPath);
+                }
+            }
+
+            // Additional conversion with resolution settings
+            string resolutionOutputDir = Path.Combine(Directory.GetCurrentDirectory(), "ResolutionOutput");
+            Directory.CreateDirectory(resolutionOutputDir);
+            string[] inputs = new string[] { sampleHtmlPath, sampleHtmlPath };
+            for (int i = 0; i < inputs.Length; i++)
+            {
+                string inputPath = inputs[i];
+                using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath))
+                {
+                    var options = new Aspose.Html.Saving.ImageSaveOptions(Aspose.Html.Rendering.Image.ImageFormat.Jpeg);
+                    options.HorizontalResolution = 300;
+                    options.VerticalResolution = 300;
+                    string outputPath = Path.Combine(resolutionOutputDir, $"output_{i}.jpg");
+                    Aspose.Html.Converters.Converter.ConvertHTML(document, options, outputPath);
+                }
+            }
+
+            // Template conversion example
+            string jsonPath = Path.Combine(Directory.GetCurrentDirectory(), "data.json");
+            if (!File.Exists(jsonPath))
+            {
+                File.WriteAllText(jsonPath, "{\"title\":\"Hello from template\"}");
+            }
+
+            string templatePath = Path.Combine(Directory.GetCurrentDirectory(), "template.html");
+            if (!File.Exists(templatePath))
+            {
+                File.WriteAllText(templatePath, "<html><body><h1>{{title}}</h1></body></html>");
+            }
+
+            Aspose.Html.Converters.TemplateData templateData = new Aspose.Html.Converters.TemplateData(jsonPath);
+            Aspose.Html.Loading.TemplateLoadOptions loadOptions = new Aspose.Html.Loading.TemplateLoadOptions();
+            using (Aspose.Html.HTMLDocument resultDoc = Aspose.Html.Converters.Converter.ConvertTemplate(templatePath, templateData, loadOptions))
+            {
+                string templateOutputPath = Path.Combine(Directory.GetCurrentDirectory(), "template_output.html");
+                resultDoc.Save(templateOutputPath);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/publish_validation_summaries_to_dashboard_for_continuous_monitoring_website_accessibility_status.cs b/web-accessibility/publish_validation_summaries_to_dashboard_for_continuous_monitoring_website_accessibility_status.cs
new file mode 100644
index 0000000..91e190e
--- /dev/null
+++ b/web-accessibility/publish_validation_summaries_to_dashboard_for_continuous_monitoring_website_accessibility_status.cs
@@ -0,0 +1,65 @@
+// Publish validation summaries to a dashboard for continuous monitoring of website accessibility status.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare sample HTML file
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src='image.png'></body></html>";
+            string tempFile = Path.Combine(Path.GetTempPath(), "sample.html");
+            File.WriteAllText(tempFile, htmlContent);
+
+            // Initialize accessibility validator
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(tempFile))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    string attributeValue = element.GetAttribute("alt");
+                                    Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                                else
+                                {
+                                    Console.WriteLine($"Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+            }
+
+            // Clean up temporary file
+            if (File.Exists(tempFile))
+            {
+                File.Delete(tempFile);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/query_specific_rule_by_code_accessibilityrules_getrule_show_detailed_guidance.cs b/web-accessibility/query_specific_rule_by_code_accessibilityrules_getrule_show_detailed_guidance.cs
new file mode 100644
index 0000000..e4d3b72
--- /dev/null
+++ b/web-accessibility/query_specific_rule_by_code_accessibilityrules_getrule_show_detailed_guidance.cs
@@ -0,0 +1,48 @@
+// Query a specific rule by code using AccessibilityRules.GetRule to show detailed guidance.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare a minimal HTML file
+            string inputPath = "sample.html";
+            if (!File.Exists(inputPath))
+            {
+                File.WriteAllText(inputPath, "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>");
+            }
+
+            // Load the HTML document
+            var document = new Aspose.Html.HTMLDocument(inputPath);
+
+            // Initialize WebAccessibility
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+            // Retrieve principle, guideline, and criterion
+            var principle = webAccessibility.Rules.GetPrinciple("1.1");
+            var guideline = principle?.GetGuideline("1.1.1");
+            var criterion = guideline?.GetCriterion("1.1.1.1");
+
+            if (criterion != null)
+            {
+                Console.WriteLine("{0}:{1} - {2}", criterion.Code, criterion.Description, criterion.Level);
+                foreach (Aspose.Html.Accessibility.IRule technique in criterion.SufficientTechniques)
+                {
+                    Console.WriteLine("{0}:{1}", technique.Code, technique.Description);
+                }
+            }
+            else
+            {
+                Console.WriteLine("Criterion not found.");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/re_run_validation_after_html_modifications_confirm_previously_reported_issues_resolved.cs b/web-accessibility/re_run_validation_after_html_modifications_confirm_previously_reported_issues_resolved.cs
new file mode 100644
index 0000000..39e1191
--- /dev/null
+++ b/web-accessibility/re_run_validation_after_html_modifications_confirm_previously_reported_issues_resolved.cs
@@ -0,0 +1,75 @@
+// Re‑run validation after HTML modifications to confirm that previously reported issues are resolved.
+
+using System;
+using System.IO;
+using System.Text;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare sample HTML content
+            string htmlContent = @"<!DOCTYPE html>
+<html>
+<head><title>Sample</title></head>
+<body>
+    <h1>Welcome</h1>
+    <img src='missing.jpg' alt=''>
+    <a href=''>Empty link</a>
+</body>
+</html>";
+
+            // Write content to a temporary file
+            string tempFilePath = Path.Combine(Path.GetTempPath(), "sample.html");
+            File.WriteAllText(tempFilePath, htmlContent, Encoding.UTF8);
+
+            // Load the HTML document
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(tempFilePath);
+
+            // Create WebAccessibility instance and validator
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Perform validation
+            Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+            // Output validation results
+            if (!validationResult.Success)
+            {
+                foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                {
+                    if (!detail.Success)
+                    {
+                        Console.WriteLine($"{detail.Rule.Code}: {detail.Rule.Description}");
+                        foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in detail.Errors)
+                        {
+                            Aspose.Html.Accessibility.IError error = techResult.Error;
+                            Console.WriteLine($"  Error: {error.ErrorMessage}");
+                            if (error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                            {
+                                Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)error.Target.Item;
+                                Console.WriteLine($"  Element HTML: {element.OuterHTML}");
+                            }
+                        }
+                    }
+                }
+            }
+            else
+            {
+                Console.WriteLine("Accessibility validation succeeded with no errors.");
+            }
+
+            // Clean up temporary file
+            if (File.Exists(tempFilePath))
+            {
+                File.Delete(tempFilePath);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"An error occurred: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/read_validationresult_description_obtain_high_level_summary_accessibility_check_outcome.cs b/web-accessibility/read_validationresult_description_obtain_high_level_summary_accessibility_check_outcome.cs
new file mode 100644
index 0000000..5bfd7af
--- /dev/null
+++ b/web-accessibility/read_validationresult_description_obtain_high_level_summary_accessibility_check_outcome.cs
@@ -0,0 +1,81 @@
+// Read ValidationResult.Description to obtain a high‑level summary of the accessibility check outcome.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Create a temporary HTML file with sample content
+            string htmlPath = Path.Combine(Path.GetTempPath(), "sample.html");
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><div id='test' aria-label=''></div></body></html>";
+            File.WriteAllText(htmlPath, htmlContent);
+
+            // Initialize accessibility validator
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // First validation block: detailed output
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlPath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    string attributeValue = element.GetAttribute("id");
+                                    Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+            }
+
+            // Second validation block: simple error messages
+            using (Aspose.Html.HTMLDocument document2 = new Aspose.Html.HTMLDocument(htmlPath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult2 = validator.Validate(document2);
+                if (!validationResult2.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult2.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Console.WriteLine(techResult.Error.ErrorMessage);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Clean up temporary file
+            if (File.Exists(htmlPath))
+                File.Delete(htmlPath);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/redirect_console_output_of_validation_issues_to_log_file_for_persistent_storage.cs b/web-accessibility/redirect_console_output_of_validation_issues_to_log_file_for_persistent_storage.cs
new file mode 100644
index 0000000..cd26cdd
--- /dev/null
+++ b/web-accessibility/redirect_console_output_of_validation_issues_to_log_file_for_persistent_storage.cs
@@ -0,0 +1,33 @@
+// Redirect console output of validation issues to a log file for persistent storage.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string htmlPath = "sample.html";
+            if (!File.Exists(htmlPath))
+            {
+                File.WriteAllText(htmlPath, "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello</h1></body></html>");
+            }
+
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlPath);
+            Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+            Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+            string resultString = validationResult.SaveToString();
+
+            string logPath = "validation_log.txt";
+            File.WriteAllText(logPath, resultString);
+
+            Console.WriteLine("Validation completed. Results written to " + logPath);
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/retrieve_contrast_ratio_values_for_specific_foreground_and_background_colors_log_failures.cs b/web-accessibility/retrieve_contrast_ratio_values_for_specific_foreground_and_background_colors_log_failures.cs
new file mode 100644
index 0000000..8a34af7
--- /dev/null
+++ b/web-accessibility/retrieve_contrast_ratio_values_for_specific_foreground_and_background_colors_log_failures.cs
@@ -0,0 +1,117 @@
+// Retrieve contrast ratio values for specific foreground and background colors and log any failures.
+
+using System;
+using System.IO;
+using System.Drawing;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Define input and output folders
+            string inputFolder = "Input";
+            string outputFolder = "Output";
+
+            // Ensure output folder exists
+            if (!Directory.Exists(outputFolder))
+                Directory.CreateDirectory(outputFolder);
+
+            // Ensure input folder exists
+            if (!Directory.Exists(inputFolder))
+                Directory.CreateDirectory(inputFolder);
+
+            // Create a sample SVG file if none exist
+            string[] existingSvg = Directory.GetFiles(inputFolder, "*.svg");
+            if (existingSvg.Length == 0)
+            {
+                string sampleSvgPath = Path.Combine(inputFolder, "sample.svg");
+                File.WriteAllText(sampleSvgPath,
+@"<svg width='200' height='200' xmlns='http://www.w3.org/2000/svg'>
+  <rect width='200' height='200' fill='red'/>
+</svg>");
+            }
+
+            // Get SVG files
+            string[] svgFiles = Directory.GetFiles(inputFolder, "*.svg");
+            int total = svgFiles.Length;
+
+            for (int i = 0; i < total; i++)
+            {
+                string svgPath = svgFiles[i];
+                string outputPath = Path.Combine(outputFolder,
+                    Path.GetFileNameWithoutExtension(svgPath) + ".png");
+
+                using (Aspose.Html.Dom.Svg.SVGDocument document = new Aspose.Html.Dom.Svg.SVGDocument(svgPath))
+                {
+                    Aspose.Html.Saving.ImageSaveOptions options = new Aspose.Html.Saving.ImageSaveOptions();
+                    options.HorizontalResolution = 300;
+                    options.VerticalResolution = 300;
+                    options.BackgroundColor = Color.White;
+                    options.UseAntialiasing = true;
+
+                    Aspose.Html.Converters.Converter.ConvertSVG(document, options, outputPath);
+                }
+
+                int percent = (i + 1) * 100 / total;
+                Console.WriteLine($"Converted {i + 1}/{total} ({percent}%) - {Path.GetFileName(outputPath)}");
+            }
+
+            // Prepare a sample HTML file
+            string htmlPath = Path.Combine(inputFolder, "sample.html");
+            if (!File.Exists(htmlPath))
+            {
+                File.WriteAllText(htmlPath,
+@"<!DOCTYPE html>
+<html>
+<head><title>Sample</title></head>
+<body><h1>Hello, Aspose.HTML!</h1></body>
+</html>");
+            }
+
+            // Convert HTML to BMP image
+            string bmpOutputPath = Path.Combine(outputFolder, "sample.bmp");
+            Aspose.Html.HTMLDocument htmlDocForBmp = new Aspose.Html.HTMLDocument(htmlPath);
+            Aspose.Html.Saving.ImageSaveOptions bmpOptions = new Aspose.Html.Saving.ImageSaveOptions(Aspose.Html.Rendering.Image.ImageFormat.Bmp);
+            bmpOptions.UseAntialiasing = false;
+            bmpOptions.HorizontalResolution = 300;
+            bmpOptions.VerticalResolution = 300;
+            bmpOptions.BackgroundColor = Color.Beige;
+            Aspose.Html.Converters.Converter.ConvertHTML(htmlDocForBmp, bmpOptions, bmpOutputPath);
+
+            // Convert HTML to PDF with background color
+            string pdfOutputPath = Path.Combine(outputFolder, "sample.pdf");
+            Aspose.Html.HTMLDocument htmlDocForPdf = new Aspose.Html.HTMLDocument(htmlPath);
+            Aspose.Html.Saving.PdfSaveOptions pdfOptions = new Aspose.Html.Saving.PdfSaveOptions();
+            pdfOptions.HorizontalResolution = 300;
+            pdfOptions.VerticalResolution = 300;
+            pdfOptions.BackgroundColor = Color.AliceBlue;
+            Aspose.Html.Converters.Converter.ConvertHTML(htmlDocForPdf, pdfOptions, pdfOutputPath);
+
+            // Convert EPUB to TIFF image (if EPUB file exists)
+            string epubPath = Path.Combine(inputFolder, "sample.epub");
+            if (File.Exists(epubPath))
+            {
+                string epubOutputPath = Path.Combine(outputFolder, "sample_epub.tiff");
+                using (Stream epubStream = File.OpenRead(epubPath))
+                {
+                    Aspose.Html.Saving.ImageSaveOptions epubOptions = new Aspose.Html.Saving.ImageSaveOptions(Aspose.Html.Rendering.Image.ImageFormat.Tiff);
+                    epubOptions.Compression = Aspose.Html.Rendering.Image.Compression.None;
+                    epubOptions.UseAntialiasing = true;
+                    epubOptions.HorizontalResolution = 300;
+                    epubOptions.VerticalResolution = 300;
+                    epubOptions.PageSetup.AnyPage = new Aspose.Html.Drawing.Page(
+                        new Aspose.Html.Drawing.Size(800, 600),
+                        new Aspose.Html.Drawing.Margin(10, 10, 10, 10));
+
+                    Aspose.Html.Converters.Converter.ConvertEPUB(epubStream, epubOptions, epubOutputPath);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/retrieve_validationresult_returned_by_validate_and_store_for_further_processing.cs b/web-accessibility/retrieve_validationresult_returned_by_validate_and_store_for_further_processing.cs
new file mode 100644
index 0000000..520bc2e
--- /dev/null
+++ b/web-accessibility/retrieve_validationresult_returned_by_validate_and_store_for_further_processing.cs
@@ -0,0 +1,56 @@
+// Retrieve the ValidationResult returned by Validate and store it for further processing.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare a minimal HTML file for validation
+            string inputPath = "sample.html";
+            if (!File.Exists(inputPath))
+            {
+                File.WriteAllText(inputPath,
+                    "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>");
+            }
+
+            // Initialize accessibility validator
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load the document and perform validation
+            using (var document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                var validationResult = validator.Validate(document);
+
+                if (!validationResult.Success)
+                {
+                    Console.WriteLine("Validation failed. Details:");
+                    foreach (var detail in validationResult.Details)
+                    {
+                        Console.WriteLine($"Rule: {detail.Rule.Code} - {detail.Rule.Description}, Success: {detail.Success}");
+                    }
+
+                    // Save validation result to XML string
+                    using (var sw = new StringWriter())
+                    {
+                        validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                        Console.WriteLine("Validation result XML:");
+                        Console.WriteLine(sw.ToString());
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Validation succeeded.");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/run_batch_validation_on_all_html_files_in_project_folder_and_produce_consolidated_json_report.cs b/web-accessibility/run_batch_validation_on_all_html_files_in_project_folder_and_produce_consolidated_json_report.cs
new file mode 100644
index 0000000..81506a1
--- /dev/null
+++ b/web-accessibility/run_batch_validation_on_all_html_files_in_project_folder_and_produce_consolidated_json_report.cs
@@ -0,0 +1,59 @@
+// Run batch validation on all HTML files in a project folder and produce a consolidated JSON report.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare folders
+            string inputFolder = "Input";
+            string outputFolder = "Output";
+            Directory.CreateDirectory(inputFolder);
+            Directory.CreateDirectory(outputFolder);
+
+            // Define file paths
+            string templatePath = Path.Combine(inputFolder, "template.html");
+            string jsonPath = Path.Combine(inputFolder, "data.json");
+            string outputPath = Path.Combine(outputFolder, "result.html");
+
+            // Create a minimal template if it does not exist
+            if (!File.Exists(templatePath))
+            {
+                File.WriteAllText(templatePath,
+                    "<html><body><h1>{{title}}</h1><p>{{description}}</p></body></html>");
+            }
+
+            // Create a minimal JSON data file if it does not exist
+            if (!File.Exists(jsonPath))
+            {
+                File.WriteAllText(jsonPath,
+                    "{ \"title\": \"Hello World\", \"description\": \"Sample description\" }");
+            }
+
+            // Load template data
+            Aspose.Html.Converters.TemplateData templateData =
+                new Aspose.Html.Converters.TemplateData(jsonPath);
+
+            // Load options for the template
+            Aspose.Html.Loading.TemplateLoadOptions loadOptions =
+                new Aspose.Html.Loading.TemplateLoadOptions();
+
+            // Convert the template to an HTML document
+            Aspose.Html.HTMLDocument resultDocument =
+                Aspose.Html.Converters.Converter.ConvertTemplate(templatePath, templateData, loadOptions);
+
+            // Save the resulting HTML
+            resultDocument.Save(outputPath);
+
+            Console.WriteLine($"Conversion completed. Output saved to: {outputPath}");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/run_default_accessibility_validation_direct_console_output_debug_logger_development_monitoring.cs b/web-accessibility/run_default_accessibility_validation_direct_console_output_debug_logger_development_monitoring.cs
new file mode 100644
index 0000000..74b593e
--- /dev/null
+++ b/web-accessibility/run_default_accessibility_validation_direct_console_output_debug_logger_development_monitoring.cs
@@ -0,0 +1,130 @@
+// Run default accessibility validation and direct console output to a debug logger for development monitoring.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content with an image missing alt attribute (accessibility issue)
+            string htmlContent = @"
+                <html>
+                    <head><title>Sample</title></head>
+                    <body>
+                        <h1>Welcome</h1>
+                        <img src='sample.png'>
+                        <a href='https://example.com'>Link</a>
+                    </body>
+                </html>";
+
+            // 1. Basic validation – print success message or errors
+            var webAccessibility1 = new Aspose.Html.Accessibility.WebAccessibility();
+            var validator1 = webAccessibility1.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (var document1 = new Aspose.Html.HTMLDocument(htmlContent))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator1.Validate(document1);
+                if (validationResult.Success)
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+                else
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                Console.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // 2. Detailed error information – tag, attribute and message
+            var webAccessibility2 = new Aspose.Html.Accessibility.WebAccessibility();
+            var validator2 = webAccessibility2.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (var document2 = new Aspose.Html.HTMLDocument(htmlContent))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator2.Validate(document2);
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    string attributeValue = element.GetAttribute("alt") ?? "(none)";
+                                    Console.WriteLine($"Tag: {tagName}, Attribute: alt, Value: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // 3. Simple error messages for HTMLElement targets
+            var webAccessibility3 = new Aspose.Html.Accessibility.WebAccessibility();
+            var validator3 = webAccessibility3.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (var document3 = new Aspose.Html.HTMLDocument(htmlContent))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator3.Validate(document3);
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Console.WriteLine(techResult.Error.ErrorMessage);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // 4. Retrieve principle, guideline, and criterion information
+            var webAccessibility4 = new Aspose.Html.Accessibility.WebAccessibility();
+            // Example codes – adjust as needed for real documents
+            string principleCode = "1.1";      // Example principle code
+            string guidelineCode = "1.1.1";    // Example guideline code
+            string criterionCode = "1.1.1.1";  // Example criterion code
+
+            Aspose.Html.Accessibility.Principle principle = webAccessibility4.Rules.GetPrinciple(principleCode);
+            if (principle != null)
+            {
+                Aspose.Html.Accessibility.Guideline guideline = principle.GetGuideline(guidelineCode);
+                if (guideline != null)
+                {
+                    Aspose.Html.Accessibility.Criterion criterion = guideline.GetCriterion(criterionCode);
+                    if (criterion != null)
+                    {
+                        Console.WriteLine($"{criterion.Code}:{criterion.Description} - {criterion.Level}");
+                        foreach (Aspose.Html.Accessibility.IRule technique in criterion.SufficientTechniques)
+                        {
+                            Console.WriteLine($"{technique.Code}:{technique.Description}");
+                        }
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/run_validation_nightly_build_process_ensure_continuous_accessibility_compliance.cs b/web-accessibility/run_validation_nightly_build_process_ensure_continuous_accessibility_compliance.cs
new file mode 100644
index 0000000..361c7b9
--- /dev/null
+++ b/web-accessibility/run_validation_nightly_build_process_ensure_continuous_accessibility_compliance.cs
@@ -0,0 +1,50 @@
+// Run validation as part of a nightly build process to ensure continuous accessibility compliance.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello, world!</h1></body></html>";
+
+            // Create WebAccessibility instance
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+            // Create validator with all validation rules
+            var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load HTML document from string
+            using (var document = new Aspose.Html.HTMLDocument(htmlContent))
+            {
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (validationResult.Success)
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+                else
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                Console.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/save_complete_validation_report_to_string_using_validationresult_savetostring_method_for_later_processing.cs b/web-accessibility/save_complete_validation_report_to_string_using_validationresult_savetostring_method_for_later_processing.cs
new file mode 100644
index 0000000..59b3404
--- /dev/null
+++ b/web-accessibility/save_complete_validation_report_to_string_using_validationresult_savetostring_method_for_later_processing.cs
@@ -0,0 +1,69 @@
+// Save the complete validation report to a string using ValidationResult.SaveToString method for later processing.
+
+using System;
+using System.IO;
+using System.Drawing;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><input type='text' id='name'></body></html>";
+            string baseUri = "http://example.com/";
+
+            // 1. Load HTML document from string
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent);
+
+            // 2. Perform accessibility validation
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(
+                webAccessibility.Rules.GetPrinciple("WCAG2AA").GetGuideline("1.1.1"),
+                Aspose.Html.Accessibility.ValidationBuilder.All);
+            Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+            // Output validation result as XML string
+            string validationXml = validationResult.SaveToString();
+            Console.WriteLine("Accessibility Validation Result (XML):");
+            Console.WriteLine(validationXml);
+
+            if (!validationResult.Success)
+            {
+                Console.WriteLine("Validation reported errors.");
+            }
+            else
+            {
+                Console.WriteLine("Validation succeeded.");
+            }
+
+            // 3. Modify input element value
+            Aspose.Html.HTMLDocument docForSave = new Aspose.Html.HTMLDocument(htmlContent, baseUri);
+            Aspose.Html.Collections.HTMLCollection inputElements = docForSave.GetElementsByTagName("input");
+            if (inputElements.Length > 0)
+            {
+                Aspose.Html.HTMLInputElement input = (Aspose.Html.HTMLInputElement)inputElements[0];
+                input.Value = "John Doe";
+            }
+
+            // 4. Save modified HTML with options
+            string outputHtmlPath = "output.html";
+            Aspose.Html.Saving.HTMLSaveOptions htmlSaveOptions = new Aspose.Html.Saving.HTMLSaveOptions();
+            htmlSaveOptions.SerializeInputValue = true;
+            docForSave.Save(outputHtmlPath, htmlSaveOptions);
+            Console.WriteLine($"Modified HTML saved to '{outputHtmlPath}'.");
+
+            // 5. Convert HTML to MHTML
+            string outputMhtmlPath = "output.mhtml";
+            Aspose.Html.Saving.MHTMLSaveOptions mhtmlOptions = new Aspose.Html.Saving.MHTMLSaveOptions();
+            Aspose.Html.Converters.Converter.ConvertHTML(htmlContent, baseUri, mhtmlOptions, outputMhtmlPath);
+            Console.WriteLine($"MHTML file saved to '{outputMhtmlPath}'.");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("An error occurred:");
+            Console.WriteLine(ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/save_validation_results_to_json_file_for_later_analysis_and_integration_with_reporting_tools.cs b/web-accessibility/save_validation_results_to_json_file_for_later_analysis_and_integration_with_reporting_tools.cs
new file mode 100644
index 0000000..dcb9311
--- /dev/null
+++ b/web-accessibility/save_validation_results_to_json_file_for_later_analysis_and_integration_with_reporting_tools.cs
@@ -0,0 +1,96 @@
+// Save validation results to a JSON file for later analysis and integration with reporting tools.
+
+using System;
+using System.IO;
+using System.Text.Json.Nodes;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1></body></html>";
+            string htmlPath = "sample.html";
+            File.WriteAllText(htmlPath, htmlContent);
+
+            // Accessibility validation
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent))
+            {
+                Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                using (StringWriter sw = new StringWriter())
+                {
+                    validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                    string validationXml = sw.ToString();
+                    Console.WriteLine("Accessibility Validation Result (XML):");
+                    Console.WriteLine(validationXml);
+                }
+            }
+
+            // Prepare sample JSON data for template
+            string jsonPath = "data.json";
+            File.WriteAllText(jsonPath, "{\"title\":\"World\"}");
+
+            // Prepare a simple template file
+            string templatePath = "template.html";
+            string templateContent = "<!DOCTYPE html><html><head><title>{{title}}</title></head><body><h1>Hello {{title}}!</h1></body></html>";
+            File.WriteAllText(templatePath, templateContent);
+
+            // Convert template using JSON data
+            Aspose.Html.Converters.TemplateData templateData = new Aspose.Html.Converters.TemplateData(jsonPath);
+            Aspose.Html.Loading.TemplateLoadOptions loadOptions = new Aspose.Html.Loading.TemplateLoadOptions();
+            Aspose.Html.HTMLDocument convertedDoc = Aspose.Html.Converters.Converter.ConvertTemplate(templatePath, templateData, loadOptions);
+            string convertedOutputPath = "converted.html";
+            convertedDoc.Save(convertedOutputPath);
+            Console.WriteLine($"Template converted and saved to '{convertedOutputPath}'.");
+
+            // Configure network service with custom message handler
+            Aspose.Html.Configuration configuration = new Aspose.Html.Configuration();
+            Aspose.Html.Services.INetworkService network = configuration.GetService<Aspose.Html.Services.INetworkService>();
+            network.MessageHandlers.Add(new JsonModifyingHandler());
+
+            // Load HTML document with custom configuration and save
+            using (Aspose.Html.HTMLDocument docWithConfig = new Aspose.Html.HTMLDocument(htmlPath, configuration))
+            {
+                string finalOutputPath = "final.html";
+                docWithConfig.Save(finalOutputPath);
+                Console.WriteLine($"Document loaded with custom configuration and saved to '{finalOutputPath}'.");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
+
+// Custom network message handler that modifies JSON responses
+class JsonModifyingHandler : Aspose.Html.Net.MessageHandler
+{
+    public override void Invoke(Aspose.Html.Net.INetworkOperationContext context)
+    {
+        // Continue the pipeline
+        Next(context);
+
+        if (context.Response.Content == null)
+            return;
+
+        string json = context.Response.Content.ReadAsString();
+        try
+        {
+            JsonNode node = JsonNode.Parse(json);
+            // Example modification: add a new property
+            node["addedProperty"] = "newValue";
+            string newJson = node.ToJsonString();
+            Console.WriteLine("Modified JSON response:");
+            Console.WriteLine(newJson);
+        }
+        catch
+        {
+            // Ignore parsing errors
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/save_validation_results_to_xml_for_legacy_system_compatibility.cs b/web-accessibility/save_validation_results_to_xml_for_legacy_system_compatibility.cs
new file mode 100644
index 0000000..e59a6da
--- /dev/null
+++ b/web-accessibility/save_validation_results_to_xml_for_legacy_system_compatibility.cs
@@ -0,0 +1,36 @@
+// Save validation results to an XML file for compatibility with legacy systems and workflows.
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputPath = "sample.html";
+            if (!System.IO.File.Exists(inputPath))
+            {
+                System.IO.File.WriteAllText(inputPath, "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello</h1></body></html>");
+            }
+
+            string outputPath = "validation_results.xml";
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                using (System.IO.StringWriter sw = new System.IO.StringWriter())
+                {
+                    validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                    string xmlContent = sw.ToString();
+                    System.IO.File.WriteAllText(outputPath, xmlContent);
+                }
+            }
+
+            System.Console.WriteLine("Validation results saved to " + outputPath);
+        }
+        catch (System.Exception ex)
+        {
+            System.Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/schedule_windows_task_scheduler_job_runs_batch_validation_all_html_files_nightly.cs b/web-accessibility/schedule_windows_task_scheduler_job_runs_batch_validation_all_html_files_nightly.cs
new file mode 100644
index 0000000..f953cd1
--- /dev/null
+++ b/web-accessibility/schedule_windows_task_scheduler_job_runs_batch_validation_all_html_files_nightly.cs
@@ -0,0 +1,64 @@
+// Schedule a Windows Task Scheduler job that runs batch validation on all HTML files nightly.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputFolder = "Input";
+            string outputFolder = "Output";
+
+            Directory.CreateDirectory(inputFolder);
+            Directory.CreateDirectory(outputFolder);
+
+            // Create a minimal sample MHTML file if none exist
+            string sampleMhtmlPath = Path.Combine(inputFolder, "sample.mht");
+            if (!File.Exists(sampleMhtmlPath))
+            {
+                // Simple HTML content saved with .mht extension (for demo purposes)
+                File.WriteAllText(sampleMhtmlPath, "<html><body><h1>Sample MHTML</h1></body></html>");
+            }
+
+            ConvertMhtmlFilesInFolder(inputFolder, outputFolder);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+
+    static void ConvertMhtmlFilesInFolder(string inputFolder, string outputFolder)
+    {
+        foreach (string mhtmlPath in Directory.GetFiles(inputFolder, "*.mht"))
+        {
+            using (FileStream stream = File.OpenRead(mhtmlPath))
+            {
+                // Configure network logging (optional)
+                var configuration = new Aspose.Html.Configuration();
+                var network = configuration.GetService<Aspose.Html.Services.INetworkService>();
+                network.MessageHandlers.Add(new LogHandler());
+
+                var options = new Aspose.Html.Saving.PdfSaveOptions();
+
+                string pdfFileName = Path.GetFileNameWithoutExtension(mhtmlPath) + ".pdf";
+                string pdfPath = Path.Combine(outputFolder, pdfFileName);
+
+                Aspose.Html.Converters.Converter.ConvertMHTML(stream, options, pdfPath);
+                Console.WriteLine($"Converted: {Path.GetFileName(mhtmlPath)} -> {pdfFileName}");
+            }
+        }
+    }
+}
+
+class LogHandler : Aspose.Html.Net.MessageHandler
+{
+    public override void Invoke(Aspose.Html.Net.INetworkOperationContext context)
+    {
+        Next(context);
+        Console.WriteLine($"{context.Request.RequestUri} | {context.Response.StatusCode}");
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/select_desired_output_format_enumeration_before_saving_results.cs b/web-accessibility/select_desired_output_format_enumeration_before_saving_results.cs
new file mode 100644
index 0000000..356113f
--- /dev/null
+++ b/web-accessibility/select_desired_output_format_enumeration_before_saving_results.cs
@@ -0,0 +1,39 @@
+// Select the desired output format by using the ValidationResultSaveFormat enumeration before saving results.
+
+using System;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+using Aspose.Html.Accessibility.Saving;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputPath = "sample.html";
+            if (!File.Exists(inputPath))
+            {
+                File.WriteAllText(inputPath, "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello World</h1></body></html>");
+            }
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                AccessibilityValidator validator = new WebAccessibility().CreateValidator();
+                ValidationResult validationResult = validator.Validate(document);
+                using (StringWriter sw = new StringWriter())
+                {
+                    validationResult.SaveTo(sw, ValidationResultSaveFormat.XML);
+                    string xml = sw.ToString();
+                    Console.WriteLine(xml);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/serialize_validationresult_to_json_using_custom_serialization_for_external_tool_integration.cs b/web-accessibility/serialize_validationresult_to_json_using_custom_serialization_for_external_tool_integration.cs
new file mode 100644
index 0000000..dc691a8
--- /dev/null
+++ b/web-accessibility/serialize_validationresult_to_json_using_custom_serialization_for_external_tool_integration.cs
@@ -0,0 +1,52 @@
+// Serialize the ValidationResult to JSON using custom serialization for external tool integration.
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Text.Json;
+using Aspose.Html;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputPath = "sample.html";
+            if (!File.Exists(inputPath))
+            {
+                File.WriteAllText(inputPath, "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello</h1></body></html>");
+            }
+
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath);
+            Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+            Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+            var details = new List<object>();
+            foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+            {
+                details.Add(new
+                {
+                    RuleCode = detail.Rule.Code,
+                    RuleDescription = detail.Rule.Description,
+                    Success = detail.Success
+                });
+            }
+
+            var resultObject = new
+            {
+                Success = validationResult.Success,
+                Details = details
+            };
+
+            string json = JsonSerializer.Serialize(resultObject, new JsonSerializerOptions { WriteIndented = true });
+            Console.WriteLine(json);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/serialize_validationresult_to_xml_using_custom_serialization_for_legacy_system_compatibility.cs b/web-accessibility/serialize_validationresult_to_xml_using_custom_serialization_for_legacy_system_compatibility.cs
new file mode 100644
index 0000000..69163ff
--- /dev/null
+++ b/web-accessibility/serialize_validationresult_to_xml_using_custom_serialization_for_legacy_system_compatibility.cs
@@ -0,0 +1,34 @@
+// Serialize the ValidationResult to XML using custom serialization for legacy system compatibility.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputPath = "sample.html";
+            if (!System.IO.File.Exists(inputPath))
+            {
+                System.IO.File.WriteAllText(inputPath, "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1></body></html>");
+            }
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                using (System.IO.StringWriter sw = new System.IO.StringWriter())
+                {
+                    validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                    string xml = sw.ToString();
+                    System.Console.WriteLine(xml);
+                }
+            }
+        }
+        catch (System.Exception ex)
+        {
+            System.Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/set_custom_issue_severity_threshold_high_priority_accessibility_problems.cs b/web-accessibility/set_custom_issue_severity_threshold_high_priority_accessibility_problems.cs
new file mode 100644
index 0000000..b876aac
--- /dev/null
+++ b/web-accessibility/set_custom_issue_severity_threshold_high_priority_accessibility_problems.cs
@@ -0,0 +1,79 @@
+// Set a custom issue severity threshold so that only high‑priority accessibility problems are reported.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src='image.png' alt=''></body></html>";
+
+            // Load HTML document
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent))
+            {
+                // Create accessibility validator
+                Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+                Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (validationResult.Success)
+                {
+                    System.Console.WriteLine("Document passed accessibility validation.");
+                }
+                else
+                {
+                    // Iterate over rule results
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            // Iterate over technique errors
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    string attributeValue = element.GetAttribute("alt");
+                                    System.Console.WriteLine($"Tag: {tagName}, Attribute (alt): {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                                else
+                                {
+                                    System.Console.WriteLine($"Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // Retrieve principle, guideline, and criterion information
+                Aspose.Html.Accessibility.Principle principle = webAccessibility.Rules.GetPrinciple("Perceivable");
+                if (principle != null)
+                {
+                    Aspose.Html.Accessibility.Guideline guideline = principle.GetGuideline("Text Alternatives");
+                    if (guideline != null)
+                    {
+                        Aspose.Html.Accessibility.Criterion criterion = guideline.GetCriterion("1.1.1");
+                        if (criterion != null)
+                        {
+                            System.Console.WriteLine($"{criterion.Code}:{criterion.Description} - {criterion.Level}");
+                            foreach (Aspose.Html.Accessibility.IRule technique in criterion.SufficientTechniques)
+                            {
+                                System.Console.WriteLine($"{technique.Code}:{technique.Description}");
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/stream_validation_results_to_network_socket_using_custom_textwriter_for_remote_monitoring.cs b/web-accessibility/stream_validation_results_to_network_socket_using_custom_textwriter_for_remote_monitoring.cs
new file mode 100644
index 0000000..8b8d8e3
--- /dev/null
+++ b/web-accessibility/stream_validation_results_to_network_socket_using_custom_textwriter_for_remote_monitoring.cs
@@ -0,0 +1,82 @@
+// Stream validation results to a network socket using a custom TextWriter for remote monitoring.
+
+using System;
+using System.IO;
+using System.Net.Sockets;
+
+class TimingMessageHandler : Aspose.Html.Net.MessageHandler
+{
+    public override void Invoke(Aspose.Html.Net.INetworkOperationContext context)
+    {
+        DateTime startTime = DateTime.UtcNow;
+        base.Next(context);
+        DateTime endTime = DateTime.UtcNow;
+        TimeSpan elapsed = endTime - startTime;
+        System.Diagnostics.Debug.WriteLine("Request: " + context.Request.RequestUri);
+        System.Diagnostics.Debug.WriteLine("Start: " + startTime.ToString("O"));
+        System.Diagnostics.Debug.WriteLine("End: " + endTime.ToString("O"));
+        System.Diagnostics.Debug.WriteLine("Elapsed: " + elapsed.TotalMilliseconds + " ms");
+    }
+}
+
+class HeaderMessageHandler : Aspose.Html.Net.MessageHandler
+{
+    public override void Invoke(Aspose.Html.Net.INetworkOperationContext context)
+    {
+        context.Request.Headers["X-Custom-Id"] = Guid.NewGuid().ToString();
+        base.Next(context);
+    }
+}
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample SVG content
+            string svgContent = "<svg xmlns='http://www.w3.org/2000/svg' width='100' height='100'><rect width='100' height='100' fill='red'/></svg>";
+            string baseUri = "http://example.com/";
+            string outputPdfPath = "output.pdf";
+
+            // Configure Aspose.HTML with custom message handlers
+            Aspose.Html.Configuration configuration = new Aspose.Html.Configuration();
+            Aspose.Html.Services.INetworkService networkService = configuration.GetService<Aspose.Html.Services.INetworkService>();
+            networkService.MessageHandlers.Add(new TimingMessageHandler());
+            networkService.MessageHandlers.Add(new HeaderMessageHandler());
+
+            // Convert SVG to PDF
+            Aspose.Html.Saving.PdfSaveOptions pdfOptions = new Aspose.Html.Saving.PdfSaveOptions();
+            Aspose.Html.Converters.Converter.ConvertSVG(svgContent, baseUri, pdfOptions, outputPdfPath);
+
+            // Send the generated PDF over TCP
+            byte[] payload = File.ReadAllBytes(outputPdfPath);
+            using (TcpClient client = new TcpClient("localhost", 9000))
+            using (NetworkStream networkStream = client.GetStream())
+            {
+                networkStream.Write(payload, 0, payload.Length);
+                networkStream.Flush();
+            }
+
+            // Accessibility validation of a simple HTML document
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><p>Hello</p></body></html>";
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, configuration))
+            {
+                Aspose.Html.Accessibility.WebAccessibility webAcc = new Aspose.Html.Accessibility.WebAccessibility();
+                Aspose.Html.Accessibility.AccessibilityValidator validator = webAcc.CreateValidator();
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                using (StringWriter sw = new StringWriter())
+                {
+                    validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                    Console.WriteLine("Accessibility validation result:");
+                    Console.WriteLine(sw.ToString());
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/transform_validation_json_output_xslt_generate_human_readable_html_report.cs b/web-accessibility/transform_validation_json_output_xslt_generate_human_readable_html_report.cs
new file mode 100644
index 0000000..be6cf3e
--- /dev/null
+++ b/web-accessibility/transform_validation_json_output_xslt_generate_human_readable_html_report.cs
@@ -0,0 +1,55 @@
+// Transform validation JSON output using XSLT to generate a human‑readable HTML report.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare sample template and JSON data files
+            string templatePath = "template.html";
+            string jsonPath = "data.json";
+            string outputPath = "output.html";
+
+            // Create a simple HTML template with placeholders
+            File.WriteAllText(templatePath,
+                "<html><head><title>{{title}}</title></head><body><h1>{{title}}</h1></body></html>");
+
+            // Create corresponding JSON data
+            File.WriteAllText(jsonPath, "{\"title\":\"Hello Aspose\"}");
+
+            // Load template data
+            Aspose.Html.Converters.TemplateData templateData = new Aspose.Html.Converters.TemplateData(jsonPath);
+            Aspose.Html.Loading.TemplateLoadOptions loadOptions = new Aspose.Html.Loading.TemplateLoadOptions();
+
+            // Convert the template using the data
+            Aspose.Html.HTMLDocument document = Aspose.Html.Converters.Converter.ConvertTemplate(
+                templatePath, templateData, loadOptions);
+
+            // Save the resulting HTML document
+            document.Save(outputPath);
+            Console.WriteLine($"Converted HTML saved to: {outputPath}");
+
+            // Perform accessibility validation
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator =
+                webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+            using (StringWriter sw = new StringWriter())
+            {
+                validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                Console.WriteLine("Accessibility validation result (XML):");
+                Console.WriteLine(sw.ToString());
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("An error occurred:");
+            Console.WriteLine(ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/update_audio_element_include_track_element_captions_set_kind_captions_correctly.cs b/web-accessibility/update_audio_element_include_track_element_captions_set_kind_captions_correctly.cs
new file mode 100644
index 0000000..b1e96fe
--- /dev/null
+++ b/web-accessibility/update_audio_element_include_track_element_captions_set_kind_captions_correctly.cs
@@ -0,0 +1,44 @@
+// Update an audio element to include a <track> element for captions and set kind="captions" correctly.
+
+using System;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Collections;
+using Aspose.Html.Dom;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputPath = "input.html";
+            string outputPath = "output.html";
+
+            if (!File.Exists(inputPath))
+            {
+                string sampleHtml = "<!DOCTYPE html><html><body><audio controls src=\"audio.mp3\"></audio></body></html>";
+                File.WriteAllText(inputPath, sampleHtml);
+            }
+
+            HTMLDocument document = new HTMLDocument(inputPath);
+            HTMLCollection audios = document.GetElementsByTagName("audio");
+
+            if (audios.Length > 0)
+            {
+                Element audio = audios[0];
+                Element track = document.CreateElement("track");
+                track.SetAttribute("kind", "captions");
+                track.SetAttribute("src", "captions.vtt");
+                audio.AppendChild(track);
+            }
+
+            document.Save(outputPath);
+            Console.WriteLine("Updated HTML saved to " + outputPath);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/use_accessibilityrules_getall_fetch_all_wcag_rule_codes_and_descriptions_for_ui_display.cs b/web-accessibility/use_accessibilityrules_getall_fetch_all_wcag_rule_codes_and_descriptions_for_ui_display.cs
new file mode 100644
index 0000000..2ed4503
--- /dev/null
+++ b/web-accessibility/use_accessibilityrules_getall_fetch_all_wcag_rule_codes_and_descriptions_for_ui_display.cs
@@ -0,0 +1,63 @@
+// Use AccessibilityRules.GetAll to fetch all WCAG rule codes and descriptions for UI display.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Create a minimal HTML file to work with
+            string inputPath = "sample.html";
+            File.WriteAllText(inputPath,
+                "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Accessibility Test</h1></body></html>");
+
+            // Load the HTML document
+            var document = new Aspose.Html.HTMLDocument(inputPath);
+
+            // Initialize the accessibility engine
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+            // Retrieve a principle (example code "1.1")
+            var principle = webAccessibility.Rules.GetPrinciple("1.1");
+            if (principle != null)
+            {
+                // Retrieve a guideline (example code "1.1.1")
+                var guideline = principle.GetGuideline("1.1.1");
+                if (guideline != null)
+                {
+                    // Retrieve a criterion (example code "1.1.1.1")
+                    var criterion = guideline.GetCriterion("1.1.1.1");
+                    if (criterion != null)
+                    {
+                        Console.WriteLine("{0}:{1} - {2}", criterion.Code, criterion.Description, criterion.Level);
+
+                        // List sufficient techniques for the criterion
+                        foreach (Aspose.Html.Accessibility.IRule technique in criterion.SufficientTechniques)
+                        {
+                            Console.WriteLine("{0}:{1}", technique.Code, technique.Description);
+                        }
+                    }
+                    else
+                    {
+                        Console.WriteLine("Criterion not found.");
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Guideline not found.");
+                }
+            }
+            else
+            {
+                Console.WriteLine("Principle not found.");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/use_online_color_contrast_checker_api_programmatically_verify_contrast_ratios_identified_elements.cs b/web-accessibility/use_online_color_contrast_checker_api_programmatically_verify_contrast_ratios_identified_elements.cs
new file mode 100644
index 0000000..57f1a77
--- /dev/null
+++ b/web-accessibility/use_online_color_contrast_checker_api_programmatically_verify_contrast_ratios_identified_elements.cs
@@ -0,0 +1,60 @@
+// Use the online Color Contrast Checker API to programmatically verify contrast ratios for identified elements.
+
+using System;
+using System.IO;
+using System.Drawing;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Create a simple HTML file
+            string htmlPath = "sample.html";
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><p>Hello World</p></body></html>";
+            File.WriteAllText(htmlPath, htmlContent);
+
+            // Load the HTML document
+            var document = new Aspose.Html.HTMLDocument(htmlPath);
+
+            // Set body background color
+            var body = (Aspose.Html.HTMLElement)document.GetElementsByTagName("body")[0];
+            body.Style.BackgroundColor = "lightblue";
+
+            // Change paragraph text color
+            var paragraph = (Aspose.Html.HTMLElement)document.GetElementsByTagName("p")[0];
+            paragraph.Style.Color = "darkred";
+
+            // Save the modified HTML
+            string modifiedHtmlPath = "modified.html";
+            document.Save(modifiedHtmlPath);
+
+            // Convert to PDF with a background color
+            var pdfOptions = new Aspose.Html.Saving.PdfSaveOptions();
+            pdfOptions.HorizontalResolution = 300;
+            pdfOptions.VerticalResolution = 300;
+            pdfOptions.BackgroundColor = System.Drawing.Color.AliceBlue;
+            string pdfPath = "output.pdf";
+            Aspose.Html.Converters.Converter.ConvertHTML(document, pdfOptions, pdfPath);
+
+            // Convert to TIFF image
+            var imageOptions = new Aspose.Html.Saving.ImageSaveOptions(Aspose.Html.Rendering.Image.ImageFormat.Tiff);
+            imageOptions.Compression = Aspose.Html.Rendering.Image.Compression.None;
+            imageOptions.UseAntialiasing = true;
+            imageOptions.HorizontalResolution = 300;
+            imageOptions.VerticalResolution = 300;
+            var pageSize = new Aspose.Html.Drawing.Size(800, 600);
+            var margin = new Aspose.Html.Drawing.Margin(10, 10, 10, 10);
+            imageOptions.PageSetup.AnyPage = new Aspose.Html.Drawing.Page(pageSize, margin);
+            string tiffPath = "output.tiff";
+            Aspose.Html.Converters.Converter.ConvertHTML(document, imageOptions, tiffPath);
+
+            Console.WriteLine("Processing completed successfully.");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/use_stringbuilder_textwriter_capture_xml_validation_output_in_memory.cs b/web-accessibility/use_stringbuilder_textwriter_capture_xml_validation_output_in_memory.cs
new file mode 100644
index 0000000..78a7d33
--- /dev/null
+++ b/web-accessibility/use_stringbuilder_textwriter_capture_xml_validation_output_in_memory.cs
@@ -0,0 +1,222 @@
+// Use a StringBuilder with a TextWriter to capture XML validation output in memory.
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+public class MemoryStreamProvider : Aspose.Html.IO.ICreateStreamProvider, IDisposable
+{
+    public List<MemoryStream> Streams { get; } = new List<MemoryStream>();
+
+    public Stream GetStream(string name, string extension)
+    {
+        var ms = new MemoryStream();
+        Streams.Add(ms);
+        return ms;
+    }
+
+    public Stream GetStream(string name, string extension, int page)
+    {
+        var ms = new MemoryStream();
+        Streams.Add(ms);
+        return ms;
+    }
+
+    public void ReleaseStream(Stream stream)
+    {
+        if (stream != null)
+        {
+            stream.Flush();
+        }
+    }
+
+    public void Dispose()
+    {
+        foreach (var ms in Streams)
+        {
+            ms.Dispose();
+        }
+    }
+}
+
+public class Program
+{
+    public static void Main()
+    {
+        try
+        {
+            // Step 1: Convert HTML to XPS using a stream provider
+            string htmlPath = Path.Combine(Directory.GetCurrentDirectory(), "sample.html");
+            if (!File.Exists(htmlPath))
+            {
+                File.WriteAllText(htmlPath, "<html><body><h1>Hello World</h1></body></html>");
+            }
+
+            var xpsOptions = new Aspose.Html.Saving.XpsSaveOptions();
+            using (var provider = new MemoryStreamProvider())
+            {
+                Aspose.Html.Converters.Converter.ConvertHTML(htmlPath, xpsOptions, provider);
+                var xpsStream = provider.Streams[0];
+                xpsStream.Position = 0;
+                string xpsOutputPath = Path.Combine(Directory.GetCurrentDirectory(), "sample.xps");
+                using (var fs = File.Create(xpsOutputPath))
+                {
+                    xpsStream.CopyTo(fs);
+                }
+            }
+
+            // Step 2: Accessibility validation
+            using (var document = new Aspose.Html.HTMLDocument("<!DOCTYPE html><html><body><p>Sample</p></body></html>"))
+            {
+                var validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+                var validationResult = validator.Validate(document);
+                using (var sw = new StringWriter())
+                {
+                    validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                    Console.WriteLine("Accessibility validation result:");
+                    Console.WriteLine(sw.ToString());
+                }
+            }
+
+            // Step 3: Convert multiple HTML files to JPEG images
+            string outputDirImages = Path.Combine(Directory.GetCurrentDirectory(), "output_images");
+            Directory.CreateDirectory(outputDirImages);
+            string[] inputs = new string[]
+            {
+                Path.Combine(Directory.GetCurrentDirectory(), "sample1.html"),
+                Path.Combine(Directory.GetCurrentDirectory(), "sample2.html")
+            };
+            foreach (var path in inputs)
+            {
+                if (!File.Exists(path))
+                {
+                    File.WriteAllText(path, "<html><body><p>Content</p></body></html>");
+                }
+            }
+
+            for (int i = 0; i < inputs.Length; i++)
+            {
+                using (var document = new Aspose.Html.HTMLDocument(inputs[i], Path.GetDirectoryName(inputs[i])))
+                {
+                    var div = document.CreateElement("div");
+                    div.SetAttribute("id", "myDiv");
+                    div.TextContent = "Added by code";
+                    document.Body.AppendChild(div);
+
+                    var imgOptions = new Aspose.Html.Saving.ImageSaveOptions(Aspose.Html.Rendering.Image.ImageFormat.Jpeg);
+                    using (var provider = new MemoryStreamProvider())
+                    {
+                        Aspose.Html.Converters.Converter.ConvertHTML(document, imgOptions, provider);
+                        var memory = provider.Streams[0];
+                        memory.Seek(0, SeekOrigin.Begin);
+                        string outputPath = Path.Combine(outputDirImages, $"image_{i + 1}.jpeg");
+                        using (var fs = File.Create(outputPath))
+                        {
+                            memory.CopyTo(fs);
+                        }
+                    }
+                }
+            }
+
+            // Step 4: Convert with watermark element
+            string outputDirWatermark = Path.Combine(Directory.GetCurrentDirectory(), "output_watermark");
+            Directory.CreateDirectory(outputDirWatermark);
+            for (int i = 0; i < inputs.Length; i++)
+            {
+                using (var document = new Aspose.Html.HTMLDocument(inputs[i], Path.GetDirectoryName(inputs[i])))
+                {
+                    var div = document.CreateElement("div");
+                    div.SetAttribute("style", "position:absolute; top:10px; left:10px; color:red; font-size:24px;");
+                    div.TextContent = "Watermark";
+                    document.Body.AppendChild(div);
+
+                    var imgOptions = new Aspose.Html.Saving.ImageSaveOptions(Aspose.Html.Rendering.Image.ImageFormat.Jpeg);
+                    using (var provider = new MemoryStreamProvider())
+                    {
+                        Aspose.Html.Converters.Converter.ConvertHTML(document, imgOptions, provider);
+                        var memory = provider.Streams[0];
+                        memory.Seek(0, SeekOrigin.Begin);
+                        string outputPath = Path.Combine(outputDirWatermark, $"watermark_{i + 1}.jpeg");
+                        using (var fs = File.Create(outputPath))
+                        {
+                            memory.CopyTo(fs);
+                        }
+                    }
+                }
+            }
+
+            // Step 5: Convert EPUB to XPS with timing
+            string epubPath = Path.Combine(Directory.GetCurrentDirectory(), "sample.epub");
+            if (!File.Exists(epubPath))
+            {
+                File.WriteAllBytes(epubPath, new byte[0]);
+            }
+
+            var epubOptions = new Aspose.Html.Saving.XpsSaveOptions();
+            using (var stream = File.OpenRead(epubPath))
+            using (var provider = new MemoryStreamProvider())
+            {
+                var sw = Stopwatch.StartNew();
+                Aspose.Html.Converters.Converter.ConvertEPUB(stream, epubOptions, provider);
+                sw.Stop();
+                Console.WriteLine($"EPUB conversion took {sw.Elapsed.TotalSeconds} seconds.");
+
+                if (provider.Streams.Count > 0)
+                {
+                    var resultStream = provider.Streams[0];
+                    resultStream.Position = 0;
+                    string epubOutputPath = Path.Combine(Directory.GetCurrentDirectory(), "sample_from_epub.xps");
+                    using (var fs = File.Create(epubOutputPath))
+                    {
+                        resultStream.CopyTo(fs);
+                    }
+                }
+            }
+
+            // Step 6: Batch convert EPUB files in a directory
+            string inputDir = Path.Combine(Directory.GetCurrentDirectory(), "epub_input");
+            string outputDir = Path.Combine(Directory.GetCurrentDirectory(), "epub_output");
+            Directory.CreateDirectory(inputDir);
+            Directory.CreateDirectory(outputDir);
+
+            string sampleEpubIn = Path.Combine(inputDir, "sample2.epub");
+            if (!File.Exists(sampleEpubIn))
+            {
+                File.WriteAllBytes(sampleEpubIn, new byte[0]);
+            }
+
+            string[] files = Directory.GetFiles(inputDir, "*.epub");
+            foreach (var inputPath in files)
+            {
+                try
+                {
+                    using (var stream = File.OpenRead(inputPath))
+                    using (var streamProvider = new MemoryStreamProvider())
+                    {
+                        var options = new Aspose.Html.Saving.XpsSaveOptions();
+                        Aspose.Html.Converters.Converter.ConvertEPUB(stream, options, streamProvider);
+                        if (streamProvider.Streams.Count > 0)
+                        {
+                            var resultStream = streamProvider.Streams[0];
+                            resultStream.Position = 0;
+                            string outPath = Path.Combine(outputDir, Path.GetFileNameWithoutExtension(inputPath) + ".xps");
+                            using (var output = File.Create(outPath))
+                            {
+                                resultStream.CopyTo(output);
+                            }
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine("Failed to convert " + Path.GetFileName(inputPath) + ": " + ex.Message);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/use_validator_aspnet_core_controller_check_uploaded_html_files_multimedia_accessibility_before_storage.cs b/web-accessibility/use_validator_aspnet_core_controller_check_uploaded_html_files_multimedia_accessibility_before_storage.cs
new file mode 100644
index 0000000..e1953b4
--- /dev/null
+++ b/web-accessibility/use_validator_aspnet_core_controller_check_uploaded_html_files_multimedia_accessibility_before_storage.cs
@@ -0,0 +1,40 @@
+// Use the validator in an ASP.NET Core controller to check uploaded HTML files for multimedia accessibility before storage.
+
+using System;
+using System.IO;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+using Aspose.Html;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            string inputPath = "sample.html";
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><p>Hello</p></body></html>";
+            File.WriteAllText(inputPath, htmlContent);
+            string url = new Uri(Path.GetFullPath(inputPath)).AbsoluteUri;
+
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.Guideline guideline = webAccessibility.Rules.GetPrinciple("Perceivable").GetGuideline("TimeBasedMedia");
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(guideline, Aspose.Html.Accessibility.ValidationBuilder.All);
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(url);
+            Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+            if (!validationResult.Success)
+            {
+                Console.WriteLine("Accessibility validation failed.");
+            }
+            else
+            {
+                Console.WriteLine("Accessibility validation succeeded.");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/use_validator_azure_devops_pipeline_task_publish_validation_report_build_artifact.cs b/web-accessibility/use_validator_azure_devops_pipeline_task_publish_validation_report_build_artifact.cs
new file mode 100644
index 0000000..7ad7ae4
--- /dev/null
+++ b/web-accessibility/use_validator_azure_devops_pipeline_task_publish_validation_report_build_artifact.cs
@@ -0,0 +1,36 @@
+// Use the validator in an Azure DevOps pipeline task to publish a validation report as a build artifact.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputPath = "sample.html";
+            if (!System.IO.File.Exists(inputPath))
+            {
+                System.IO.File.WriteAllText(inputPath, "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello</h1></body></html>");
+            }
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                using (System.IO.StringWriter sw = new System.IO.StringWriter())
+                {
+                    validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                    string xmlReport = sw.ToString();
+                    string outputPath = "validation_report.xml";
+                    System.IO.File.WriteAllText(outputPath, xmlReport);
+                    Console.WriteLine("Validation report saved to " + outputPath);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/use_validator_in_github_actions_workflow_to_automatically_fail_builds_when_caption_issues_detected.cs b/web-accessibility/use_validator_in_github_actions_workflow_to_automatically_fail_builds_when_caption_issues_detected.cs
new file mode 100644
index 0000000..8a6e4e6
--- /dev/null
+++ b/web-accessibility/use_validator_in_github_actions_workflow_to_automatically_fail_builds_when_caption_issues_detected.cs
@@ -0,0 +1,43 @@
+// Use the validator in a GitHub Actions workflow to automatically fail builds when caption issues are detected.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            Aspose.Html.Url baseUri = new Aspose.Html.Url("about:blank");
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument("<html><body><img src='image.png' alt='Decorative illustration'></body></html>", baseUri))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                Console.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                    Environment.Exit(1);
+                }
+                else
+                {
+                    Console.WriteLine("Accessibility validation passed.");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+            Environment.Exit(1);
+        }
+    }
+}
diff --git a/web-accessibility/use_validator_within_unit_test_assert_no_multimedia_accessibility_issues_in_sample_html.cs b/web-accessibility/use_validator_within_unit_test_assert_no_multimedia_accessibility_issues_in_sample_html.cs
new file mode 100644
index 0000000..fc14c5d
--- /dev/null
+++ b/web-accessibility/use_validator_within_unit_test_assert_no_multimedia_accessibility_issues_in_sample_html.cs
@@ -0,0 +1,84 @@
+// Use the validator within a unit test to assert that no multimedia accessibility issues exist in sample HTML.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare a minimal HTML file for validation
+            const string inputPath = "sample.html";
+            if (!File.Exists(inputPath))
+            {
+                File.WriteAllText(inputPath, "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>");
+            }
+
+            // Initialize WebAccessibility
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+            // Example 1: Validate against a specific guideline
+            // (Principle and guideline identifiers are illustrative; replace with real IDs as needed)
+            var principle = webAccessibility.Rules.GetPrinciple("WCAG2AA");
+            var guideline = principle.GetGuideline("1.1.1");
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(guideline, Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (validationResult.Success)
+                {
+                    Console.WriteLine("Document passed the specific guideline validation.");
+                }
+                else
+                {
+                    Console.WriteLine("Document failed the specific guideline validation. Details:");
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                Console.WriteLine("- " + techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Example 2: Validate using all default rules (no specific guideline)
+            Aspose.Html.Accessibility.AccessibilityValidator allRulesValidator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = allRulesValidator.Validate(document);
+
+                if (validationResult.Success)
+                {
+                    Console.WriteLine("Document passed the all‑rules validation.");
+                }
+                else
+                {
+                    Console.WriteLine("Document failed the all‑rules validation. Details:");
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                Console.WriteLine("- " + techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("An error occurred: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/validate_html_documents_retrieved_from_remote_url_loading_content_into_validator.cs b/web-accessibility/validate_html_documents_retrieved_from_remote_url_loading_content_into_validator.cs
new file mode 100644
index 0000000..2400373
--- /dev/null
+++ b/web-accessibility/validate_html_documents_retrieved_from_remote_url_loading_content_into_validator.cs
@@ -0,0 +1,98 @@
+// Validate HTML documents retrieved from a remote URL by loading the URL content into the validator.
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Ensure a sample HTML file exists
+            string sampleHtmlPath = "sample.html";
+            if (!File.Exists(sampleHtmlPath))
+            {
+                File.WriteAllText(sampleHtmlPath,
+                    "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello World</h1></body></html>");
+            }
+
+            // Load document from file and display its outer HTML
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(sampleHtmlPath))
+            {
+                string html = document.DocumentElement.OuterHTML;
+                Console.WriteLine("Document outer HTML:");
+                Console.WriteLine(html);
+            }
+
+            // Create WebAccessibility instance
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+            // Retrieve a specific guideline (example: WCAG2AA principle, 1.1.1 guideline)
+            Aspose.Html.Accessibility.Guideline guideline = webAccessibility.Rules
+                .GetPrinciple("WCAG2AA")
+                .GetGuideline("1.1.1");
+
+            // Create a validator for the specific guideline
+            Aspose.Html.Accessibility.AccessibilityValidator guidelineValidator =
+                webAccessibility.CreateValidator(guideline, Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Validate the sample document against the specific guideline
+            using (Aspose.Html.HTMLDocument docForGuideline = new Aspose.Html.HTMLDocument(sampleHtmlPath))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = guidelineValidator.Validate(docForGuideline);
+                if (!validationResult.Success)
+                {
+                    Console.WriteLine("Guideline validation errors:");
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                    {
+                        Console.WriteLine($"Rule: {detail.Rule.Code} - {detail.Rule.Description} - Success: {detail.Success}");
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Document passed the specific guideline validation.");
+                }
+            }
+
+            // Validate multiple documents (using the same file for demonstration)
+            System.Collections.Generic.List<string> urls = new System.Collections.Generic.List<string>
+            {
+                sampleHtmlPath,
+                sampleHtmlPath
+            };
+
+            string outputDir = "validation_results";
+            System.IO.Directory.CreateDirectory(outputDir);
+
+            // Create a validator for all guidelines
+            Aspose.Html.Accessibility.AccessibilityValidator allValidator =
+                webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            int index = 1;
+            foreach (string url in urls)
+            {
+                using (Aspose.Html.HTMLDocument doc = new Aspose.Html.HTMLDocument(url))
+                {
+                    Aspose.Html.Accessibility.Results.ValidationResult result = allValidator.Validate(doc);
+                    string outputPath = System.IO.Path.Combine(outputDir, $"validation_result_{index}.xml");
+
+                    // Save validation result as XML
+                    using (System.IO.StringWriter sw = new System.IO.StringWriter())
+                    {
+                        result.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                        System.IO.File.WriteAllText(outputPath, sw.ToString());
+                    }
+                }
+                index++;
+            }
+
+            Console.WriteLine($"Validation results saved to directory: {outputDir}");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/validate_html_generated_by_razor_view_at_runtime_and_log_detected_accessibility_issues.cs b/web-accessibility/validate_html_generated_by_razor_view_at_runtime_and_log_detected_accessibility_issues.cs
new file mode 100644
index 0000000..c314b13
--- /dev/null
+++ b/web-accessibility/validate_html_generated_by_razor_view_at_runtime_and_log_detected_accessibility_issues.cs
@@ -0,0 +1,44 @@
+// Validate HTML generated by a Razor view at runtime and log any accessibility issues detected.
+
+using System;
+
+namespace AsposeHtmlAccessibilityDemo
+{
+    class Program
+    {
+        static void Main()
+        {
+            try
+            {
+                string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Welcome</h1></body></html>";
+                Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+                Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+                using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent))
+                {
+                    Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                    if (validationResult.Success)
+                    {
+                        Console.WriteLine("Accessibility validation passed.");
+                    }
+                    else
+                    {
+                        foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                        {
+                            if (!ruleResult.Success)
+                            {
+                                foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                                {
+                                    Console.WriteLine(techResult.Error.ErrorMessage);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine("Error: " + ex.Message);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/validator_console_application_process_html_file_paths_command_line_arguments.cs b/web-accessibility/validator_console_application_process_html_file_paths_command_line_arguments.cs
new file mode 100644
index 0000000..34f4ebc
--- /dev/null
+++ b/web-accessibility/validator_console_application_process_html_file_paths_command_line_arguments.cs
@@ -0,0 +1,34 @@
+// Use the validator in a console application to process a list of HTML file paths via command‑line arguments.
+
+using System;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Converters;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            string[] files = args.Length > 0 ? args : new string[] { "sample.html" };
+            foreach (string filePath in files)
+            {
+                if (!File.Exists(filePath))
+                {
+                    File.WriteAllText(filePath, "<!DOCTYPE html><html><head><title>Sample</title></head><body><p>Hello World</p></body></html>");
+                }
+
+                using (HTMLDocument document = new HTMLDocument(filePath))
+                {
+                    // Placeholder for validation or processing logic
+                    Console.WriteLine($"Processed: {filePath}");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/verify_each_track_element_includes_valid_srclang_attribute_for_accessibility_standards.cs b/web-accessibility/verify_each_track_element_includes_valid_srclang_attribute_for_accessibility_standards.cs
new file mode 100644
index 0000000..517f56a
--- /dev/null
+++ b/web-accessibility/verify_each_track_element_includes_valid_srclang_attribute_for_accessibility_standards.cs
@@ -0,0 +1,63 @@
+// Verify that each <track> element includes a valid srclang attribute to meet accessibility standards.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare a minimal HTML file with an accessibility issue (img without alt)
+            string htmlFilePath = Path.Combine(Directory.GetCurrentDirectory(), "sample.html");
+            File.WriteAllText(htmlFilePath, "<!DOCTYPE html><html><head><title>Test</title></head><body><img src=\"image.png\"></body></html>");
+
+            // Initialize WebAccessibility and validator
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load the HTML document
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlFilePath))
+            {
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                // If validation failed, output details
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    string attributeValue = element.GetAttribute("alt");
+                                    Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+            }
+
+            // Clean up the temporary file
+            if (File.Exists(htmlFilePath))
+            {
+                File.Delete(htmlFilePath);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/write_formatted_validation_string_file_archival_reporting.cs b/web-accessibility/write_formatted_validation_string_file_archival_reporting.cs
new file mode 100644
index 0000000..ea04a53
--- /dev/null
+++ b/web-accessibility/write_formatted_validation_string_file_archival_reporting.cs
@@ -0,0 +1,28 @@
+// Write the formatted validation string to a text file for archival and reporting.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputPath = "sample.html";
+            string outputPath = "validation_report.txt";
+
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath);
+            Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+            Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+            string validationString = validationResult.SaveToString();
+
+            File.WriteAllText(outputPath, validationString);
+            Console.WriteLine("Validation report saved to " + outputPath);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/write_method_returning_error_messages_for_rule_identifier.cs b/web-accessibility/write_method_returning_error_messages_for_rule_identifier.cs
new file mode 100644
index 0000000..9fad097
--- /dev/null
+++ b/web-accessibility/write_method_returning_error_messages_for_rule_identifier.cs
@@ -0,0 +1,117 @@
+// Write a method that returns a list of error messages for a specified rule identifier.
+
+using System;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+using Aspose.Html.Net;
+using Aspose.Html.Services;
+using Aspose.Html.Drawing;
+
+public sealed class NetworkLogger : Aspose.Html.Net.MessageHandler
+{
+    private readonly string _logFilePath;
+
+    public NetworkLogger(string logFilePath)
+    {
+        _logFilePath = logFilePath;
+    }
+
+    public override void Invoke(Aspose.Html.Net.INetworkOperationContext context)
+    {
+        using (StreamWriter writer = new StreamWriter(_logFilePath, true))
+        {
+            writer.WriteLine("Request URI: " + context.Request.RequestUri);
+            writer.WriteLine("Request Headers: " + context.Request.Headers);
+            Next(context);
+            writer.WriteLine("Response Status: " + context.Response.StatusCode);
+            writer.WriteLine("Response Headers: " + context.Response.Headers);
+            writer.WriteLine(new string('-', 40));
+        }
+    }
+}
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare sample HTML file
+            string inputPath = Path.Combine(Environment.CurrentDirectory, "sample.html");
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>";
+            File.WriteAllText(inputPath, htmlContent);
+
+            // Output paths
+            string outputPath = Path.Combine(Environment.CurrentDirectory, "output.html");
+            string logPath = Path.Combine(Environment.CurrentDirectory, "network.log");
+
+            // Create configuration and add network logger
+            Aspose.Html.Configuration configuration = new Aspose.Html.Configuration();
+            Aspose.Html.Services.INetworkService networkService = configuration.GetService<Aspose.Html.Services.INetworkService>();
+            networkService.MessageHandlers.Add(new NetworkLogger(logPath));
+
+            // Load document with configuration
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath, configuration))
+            {
+                // Save the document to verify loading works
+                document.Save(outputPath);
+            }
+
+            // Accessibility validation - full validation
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (Aspose.Html.HTMLDocument docForValidation = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                ValidationResult validationResult = validator.Validate(docForValidation);
+                Console.WriteLine("=== Full Validation Results ===");
+                foreach (RuleValidationResult detail in validationResult.Details)
+                {
+                    Console.WriteLine($"Rule: {detail.Rule.Code} - Success: {detail.Success}");
+                }
+            }
+
+            // Accessibility validation - specific guideline
+            Aspose.Html.Accessibility.Principle principle = webAccessibility.Rules.GetPrinciple("Perceivable");
+            Aspose.Html.Accessibility.Guideline guideline = principle.GetGuideline("Text Alternatives");
+            Aspose.Html.Accessibility.AccessibilityValidator guidelineValidator = webAccessibility.CreateValidator(guideline, Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (Aspose.Html.HTMLDocument docForGuideline = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                ValidationResult guidelineResult = guidelineValidator.Validate(docForGuideline);
+                Console.WriteLine("\n=== Guideline Validation Results ===");
+                foreach (RuleValidationResult ruleResult in guidelineResult.Details)
+                {
+                    if (!ruleResult.Success)
+                    {
+                        Console.WriteLine($"Failed Rule: {ruleResult.Rule.Code} - {ruleResult.Rule.Description}");
+                        foreach (ITechniqueResult techResult in ruleResult.Errors)
+                        {
+                            if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                            {
+                                Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                Console.WriteLine($"  Element: <{element.TagName}> with outer HTML: {element.OuterHTML}");
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Retrieve and display criterion details
+            Aspose.Html.Accessibility.Criterion criterion = guideline.GetCriterion("1.1.1");
+            if (criterion != null)
+            {
+                Console.WriteLine("\n=== Criterion Details ===");
+                Console.WriteLine($"{criterion.Code}:{criterion.Description} - {criterion.Level}");
+                foreach (Aspose.Html.Accessibility.IRule technique in criterion.SufficientTechniques)
+                {
+                    Console.WriteLine($"{technique.Code}:{technique.Description}");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/write_method_returns_warning_counts_grouped_target_element_type_analysis.cs b/web-accessibility/write_method_returns_warning_counts_grouped_target_element_type_analysis.cs
new file mode 100644
index 0000000..dc1651c
--- /dev/null
+++ b/web-accessibility/write_method_returns_warning_counts_grouped_target_element_type_analysis.cs
@@ -0,0 +1,88 @@
+// Write a method that returns warning counts grouped by each target element type for analysis.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare sample HTML files
+            string inputDir = "InputHtml";
+            Directory.CreateDirectory(inputDir);
+            string file1 = Path.Combine(inputDir, "sample.html");
+            string file2 = Path.Combine(inputDir, "sample2.html");
+            File.WriteAllText(file1, "<html><body><img src='image.png'></body></html>");
+            File.WriteAllText(file2, "<html><body><button>Click</button></body></html>");
+
+            // 1. Basic accessibility validation and element details
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (var document = new Aspose.Html.HTMLDocument(file1))
+            {
+                var validationResult = validator.Validate(document);
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    var element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    string tagName = element.TagName;
+                                    string attributeValue = element.GetAttribute("alt");
+                                    Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Document passed accessibility validation.");
+                }
+            }
+
+            // 2. Retrieve principle, guideline, criterion and list sufficient techniques
+            var principle = webAccessibility.Rules.GetPrinciple("Perceivable");
+            var guideline = principle.GetGuideline("Text Alternatives");
+            var criterion = guideline.GetCriterion("Non-text Content");
+            if (criterion != null)
+            {
+                Console.WriteLine($"{criterion.Code}:{criterion.Description} - {criterion.Level}");
+                foreach (Aspose.Html.Accessibility.IRule technique in criterion.SufficientTechniques)
+                {
+                    Console.WriteLine($"{technique.Code}:{technique.Description}");
+                }
+            }
+
+            // 3. Validate multiple URLs and save results to XML files
+            List<string> urls = new List<string> { file1, file2 };
+            string outputDir = "ValidationResults";
+            Directory.CreateDirectory(outputDir);
+            int index = 1;
+            foreach (string url in urls)
+            {
+                using (var doc = new Aspose.Html.HTMLDocument(url))
+                {
+                    var result = validator.Validate(doc);
+                    string outputPath = Path.Combine(outputDir, $"validation_result_{index}.xml");
+                    File.WriteAllText(outputPath, result.ToString());
+                }
+                index++;
+            }
+
+            Console.WriteLine("Validation results saved.");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/write_validation_results_to_json_file_using_json_format.cs b/web-accessibility/write_validation_results_to_json_file_using_json_format.cs
new file mode 100644
index 0000000..f192e16
--- /dev/null
+++ b/web-accessibility/write_validation_results_to_json_file_using_json_format.cs
@@ -0,0 +1,38 @@
+// Write validation results to a JSON file by calling ValidationResult.SaveTo with Json format.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputPath = "sample.html";
+            string outputPath = "validation_results.json";
+
+            if (!File.Exists(inputPath))
+            {
+                File.WriteAllText(inputPath, "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello</h1></body></html>");
+            }
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                using (StringWriter sw = new StringWriter())
+                {
+                    validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.JSON);
+                    File.WriteAllText(outputPath, sw.ToString());
+                }
+            }
+
+            Console.WriteLine("Validation results saved to " + outputPath);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/write_validation_results_to_xml_using_validationresult_saveto_xml_format.cs b/web-accessibility/write_validation_results_to_xml_using_validationresult_saveto_xml_format.cs
new file mode 100644
index 0000000..86a592b
--- /dev/null
+++ b/web-accessibility/write_validation_results_to_xml_using_validationresult_saveto_xml_format.cs
@@ -0,0 +1,41 @@
+// Write validation results to an XML file by calling ValidationResult.SaveTo with Xml format.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Create a minimal HTML file to validate
+            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello World</h1></body></html>";
+            string inputPath = "sample.html";
+            File.WriteAllText(inputPath, htmlContent);
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                using (StringWriter sw = new StringWriter())
+                {
+                    validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                    Console.WriteLine("Accessibility validation result (XML):");
+                    Console.WriteLine(sw.ToString());
+                }
+            }
+
+            // Clean up the temporary file
+            if (File.Exists(inputPath))
+            {
+                File.Delete(inputPath);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file