From 1d0337683ffdb661e7593983bb9023216b898ed2 Mon Sep 17 00:00:00 2001
From: agent-aspose-html-examples <aspose.html@aspose.com>
Date: Fri, 2 Oct 2026 23:27:33 +0500
Subject: [PATCH] =?UTF-8?q?feat(web-accessibility):=20Add=2096=20and=20rem?=
 =?UTF-8?q?ove=2068=20renamed=20Aspose.HTML=20.NET=20C#=20examples=20for?=
 =?UTF-8?q?=20Web=20Accessibility=20=E2=80=94=20Aspose.HTML=20for=20.NET?=
 =?UTF-8?q?=2026.9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...unt-total-accessibility-errors-document.cs |  37 +++
 ...total-accessibility-warnings-html-page.cs} |  54 ++---
 ...tal_accessibility_errors_found_document.cs |  65 -----
 ...propriate-src-to-video-programmatically.cs |  58 +++++
 ...tions_and_src_to_video_programmatically.cs | 135 -----------
 ...idation-graceful-termination-batch-runs.cs |  63 +++++
 ...obtain-formatted-string-errors-warnings.cs |  25 ++
 ...s-in-video-tags-using-validation-report.cs |  57 +++++
 ...tify-pages-accessibility-ranking-issues.cs | 103 ++++++++
 ...s_with_accessibility_and_ranking_issues.cs |  79 -------
 ...ter-modifying-html-content-same-project.cs |  64 +++++
 ...ter_modifying_html_content_same_project.cs |  57 -----
 ...validating-html-document-in-application.cs |  54 +++++
 ...om-compliance-thresholds-during-checks.cs} |  37 ++-
 ...ings-as-errors-adjust-severity-settings.cs |  53 +++++
 ...consistent-rule-application-across-runs.cs |  47 ++++
 ...consistent_rule_application_across_runs.cs |  69 ------
 ...ings_as_errors_adjust_severity_settings.cs |  45 ----
 ...validates-html-file-prints-json-results.cs |  38 +++
 ...om-accessibilityrules-before-validation.cs |  74 ++++++
 ...alidate-multiple-html-files-efficiently.cs |  63 +++++
 ...ore-loading-html-document-accessibility.cs |  48 ++++
 ...om_accessibilityrules_before_validation.cs |  91 -------
 ...eferenced-track-elements-log-file-paths.cs |  56 +++++
 ...renced_by_track_elements_log_file_paths.cs |  93 --------
 ...-arguments-perform-validation-on-demand.cs |  53 +++++
 ...otify-stakeholders-accessibility-status.cs |  40 ++++
 ...ference-via-newly-created-track-element.cs |  54 +++++
 ...nt_and_reference_with_new_track_element.cs |  40 ----
 ...amps-matching-associated-media-timeline.cs |  60 +++++
 ...amps_matching_associated_media_timeline.cs | 114 ---------
 ...l-report-using-result-filtering-option.cs} |  56 ++---
 ...al_report_apply_result_filtering_option.cs | 105 ---------
 ...dia-accessibility-loaded-html-document.cs} |  22 +-
 ...th-to-run-accessibility-checks-on-page.cs} |  22 +-
 ...edia_accessibility_loaded_html_document.cs |  72 ------
 ...ath_to_run_accessibility_checks_on_page.cs |  74 ------
 ...-string-save-to-string-developer-review.cs |  24 ++
 ...sults_formatted_string_developer_review.cs |  71 ------
 ...y-errors-detected-enforce-quality-gates.cs |  47 ++++
 ...ings-to-enforce-accessibility-standards.cs |  52 ++++
 ...y_errors_detected_enforce_quality_gates.cs |  73 ------
 ...indings_enforce_accessibility_standards.cs |  68 ------
 ...isplay-using-accessibilityrules-getall.cs} |  26 +-
 ...lidate-each-page-save-results-xml-files.cs |  41 ++++
 ...t_validate_pages_save_results_xml_files.cs |  73 ------
 ...ement-issues-from-css-related-problems.cs} |  44 ++--
 ...ria-before-validation-critical-problems.cs |  45 ++++
 ...on-warnings-targeted-video-improvements.cs |  62 +++++
 ...ed-warnings-focused-remediation-efforts.cs |  55 +++++
 ...cus-particular-accessibility-techniques.cs |  56 +++++
 ...e_html_element_issues_from_css_problems.cs |  78 ------
 ...fore_validation_focus_critical_problems.cs |  70 ------
 ...description_warnings_video_improvements.cs |  59 -----
 ...on_related_warnings_focused_remediation.cs | 113 ---------
 ...cus_particular_accessibility_techniques.cs | 133 -----------
 ...-format-save-specified-output-directory.cs |  42 ++++
 ...dationresult-post-pull-request-comments.cs |  55 +++++
 ...ation-findings-quick-review-developers.cs} |  35 +--
 ...ross-all-processed-html-documents-batch.cs |  70 ++++++
 ...result_to_post_in_pull_request_comments.cs | 107 ---------
 ...alidation-messages-description-warnings.cs |  59 +++++
 ...ation_messages_for_description_warnings.cs |  68 ------
 ...y-experience-transient-network-failures.cs |  53 +++++
 ...ion-summary-for-comprehensive-reporting.cs |  64 +++++
 ...ion_summary_for_comprehensive_reporting.cs |  74 ------
 ...ath-and-validate-with-default-validator.cs |  47 ++++
 ...th_and_validate_using_default_validator.cs |  54 -----
 ...-configuration-aspnet-core-applications.cs |  59 +++++
 ..._configuration_aspnet_core_applications.cs |  76 ------
 ...evalidator-before-loading-html-document.cs |  44 ++++
 ...idator_before_loading_any_html_document.cs |  76 ------
 ...rkflows-multimedia-processing-pipeline.cs} |  41 ++--
 ...using-command-line-invocation-validator.cs |  49 ++++
 ...rkflow-automatically-test-pull-requests.cs |  47 ++++
 ...low_to_automatically_test_pull_requests.cs | 111 ---------
 ...ement-suggestions-each-identified-issue.cs |  52 ++++
 ...ls-log-rule-identifier-pass-fail-status.cs |  42 ++++
 ...ement_suggestions_each_identified_issue.cs | 134 -----------
 ..._identifier_and_its_pass_or_fail_status.cs |  54 -----
 ...alidator-in-memory-validation-scenarios.cs |  25 ++
 ...ent-object-run-accessibility-validation.cs |  39 +++
 ...ing-load-method-with-file-path-argument.cs |  34 +++
 ...local-path-into-validator-wcag-analysis.cs |  44 ++++
 ...pporting-network-or-memorybased-sources.cs |  79 +++++++
 ...alidator_support_network_memory_sources.cs |  78 ------
 ...lysis-and-troubleshooting-by-developers.cs |  35 +++
 ...controls-add-tabindex-attributes-needed.cs |  37 +++
 ...levels-advisory-technique-impact-scores.cs | 112 +++++++++
 ...h-file-sequentially-aggregating-results.cs |  61 +++++
 ...ve-validation-throughput-large-projects.cs |  30 +++
 ...ndividual-json-reports-target-directory.cs |  64 +++++
 ...h_file_sequentially_aggregating_results.cs |  44 ----
 ...ve_validation_throughput_large_projects.cs | 151 ------------
 ...vidual_json_reports_to_target_directory.cs |  79 -------
 ...onitoring-website-accessibility-status.cs} |  35 +--
 ...ityrules-getrule-show-detailed-guidance.cs |  52 ++++
 ...ityrules_getrule_show_detailed_guidance.cs |  48 ----
 ...rm-previously-reported-issues-resolved.cs} |  40 +---
 ...vel-summary-accessibility-check-outcome.cs |  71 ++++++
 ...vel_summary_accessibility_check_outcome.cs |  81 -------
 ...tion-issues-log-file-persistent-storage.cs |  43 ++++
 ...ound-background-colors-log-any-failures.cs |  72 ++++++
 ...idate-and-store-for-further-processing.cs} |  36 +--
 ...ound_and_background_colors_log_failures.cs | 117 ---------
 ...lidate_and_store_for_further_processing.cs |  56 -----
 ...folder-produce-consolidated-json-report.cs |  61 +++++
 ...debug-logger-for-development-monitoring.cs |  51 ++++
 ...re-continuous-accessibility-compliance.cs} |  22 +-
 ...er_and_produce_consolidated_json_report.cs |  59 -----
 ...put_debug_logger_development_monitoring.cs | 130 ----------
 ...avetostring-method-for-later-processing.cs |  25 ++
 ...is-and-integration-with-reporting-tools.cs |  47 ++++
 ...-compatibility-legacy-systems-workflows.cs |  48 ++++
 ...avetostring_method_for_later_processing.cs |  69 ------
 ...is_and_integration_with_reporting_tools.cs |  96 --------
 ...batch-validation-all-html-files-nightly.cs |  31 +++
 ...batch_validation_all_html_files_nightly.cs |  64 -----
 ...ormat-enumeration-before-saving-results.cs | 115 +++++++++
 ...-serialization-for-external-integration.cs |  33 +++
 ...ialization-legacy-system-compatibility.cs} |  27 ++-
 ...riority-accessibility-problems-reported.cs |  57 +++++
 ...ld_high_priority_accessibility_problems.cs |  79 -------
 ...custom-textwriter-for-remote-monitoring.cs |  70 ++++++
 ...custom_textwriter_for_remote_monitoring.cs |  82 -------
 ...slt-generate-human-readable-html-report.cs |  80 +++++++
 ...slt_generate_human_readable_html_report.cs |  55 -----
 ...nt-captions-set-kind-captions-correctly.cs |  32 +++
 ...ify-contrast-ratios-identified-elements.cs |  53 +++++
 ...er-capture-xml-validation-output-memory.cs |  42 ++++
 ...multimedia-accessibility-before-storage.cs |  48 ++++
 ...ublish-validation-report-build-artifact.cs |  48 ++++
 ...-html-file-paths-command-line-arguments.cs |  39 +++
 ...ail-builds-on-caption-issues-detection.cs} |  21 +-
 ...imedia-accessibility-issues-sample-html.cs |  53 +++++
 ...ify_contrast_ratios_identified_elements.cs |  60 -----
 ...capture_xml_validation_output_in_memory.cs | 222 ------------------
 ...dia_accessibility_issues_in_sample_html.cs |  84 -------
 ...mote-url-loading-content-into-validator.cs |  42 ++++
 ...r-view-runtime-log-accessibility-issues.cs |  48 ++++
 ...mote_url_loading_content_into_validator.cs |  98 --------
 ...clang-attribute-accessibility-standards.cs |  56 +++++
 ...-string-to-text-file-archival-reporting.cs |  53 +++++
 ...grouped-by-target-element-type-analysis.cs |  61 +++++
 ...rror-messages-specified-rule-identifier.cs |  55 +++++
 ...sing-validationresult-savetojson-format.cs |  32 +++
 ...using-validationresult-savetoxml-format.cs |  35 +++
 ...ning_error_messages_for_rule_identifier.cs | 117 ---------
 ...ts_grouped_target_element_type_analysis.cs |  88 -------
 149 files changed, 4427 insertions(+), 4804 deletions(-)
 create mode 100644 web-accessibility/access-validationresult-errors-collection-count-total-accessibility-errors-document.cs
 rename web-accessibility/{generate_plain_text_summary_validation_findings_review_developers.cs => access-validationresult-warnings-collection-count-total-accessibility-warnings-html-page.cs} (52%)
 delete mode 100644 web-accessibility/access_validationresult_errors_collection_count_total_accessibility_errors_found_document.cs
 create mode 100644 web-accessibility/add-missing-track-element-with-kind-captions-and-appropriate-src-to-video-programmatically.cs
 delete mode 100644 web-accessibility/add_missing_track_element_with_kind_captions_and_src_to_video_programmatically.cs
 create mode 100644 web-accessibility/apply-cancellation-token-validation-graceful-termination-batch-runs.cs
 create mode 100644 web-accessibility/call-validationresult-savetostring-obtain-formatted-string-errors-warnings.cs
 create mode 100644 web-accessibility/check-missing-track-elements-kind-captions-in-video-tags-using-validation-report.cs
 create mode 100644 web-accessibility/combine-validation-seo-metrics-identify-pages-accessibility-ranking-issues.cs
 delete mode 100644 web-accessibility/combine_validation_findings_with_seo_metrics_to_identify_pages_with_accessibility_and_ranking_issues.cs
 create mode 100644 web-accessibility/compare-two-validationresult-objects-detect-regressions-after-modifying-html-content-same-project.cs
 delete mode 100644 web-accessibility/compare_two_validationresult_objects_detect_regressions_after_modifying_html_content_same_project.cs
 create mode 100644 web-accessibility/configure-accessibility-validator-with-custom-settings-before-validating-html-document-in-application.cs
 rename web-accessibility/{load_html_file_from_local_path_into_validator_for_wcag_analysis.cs => configure-validator-ignore-selected-rule-codes-allowing-custom-compliance-thresholds-during-checks.cs} (56%)
 create mode 100644 web-accessibility/configure-validator-treat-caption-missing-warnings-as-errors-adjust-severity-settings.cs
 create mode 100644 web-accessibility/configure-validator-use-static-rule-repository-consistent-rule-application-across-runs.cs
 delete mode 100644 web-accessibility/configure_validator_static_rule_repository_consistent_rule_application_across_runs.cs
 delete mode 100644 web-accessibility/configure_validator_treat_caption_missing_warnings_as_errors_adjust_severity_settings.cs
 create mode 100644 web-accessibility/create-powershell-script-loads-dotnet-library-validates-html-file-prints-json-results.cs
 create mode 100644 web-accessibility/create-rule-subset-wcag-criteria-from-accessibilityrules-before-validation.cs
 create mode 100644 web-accessibility/create-static-accessibilityvalidator-instance-reuse-validate-multiple-html-files-efficiently.cs
 create mode 100644 web-accessibility/create-validator-instance-using-createvalidator-before-loading-html-document-accessibility.cs
 delete mode 100644 web-accessibility/create_custom_rule_subset_selecting_specific_wcag_criteria_from_accessibilityrules_before_validation.cs
 create mode 100644 web-accessibility/detect-absent-caption-files-referenced-track-elements-log-file-paths.cs
 delete mode 100644 web-accessibility/detect_absent_caption_files_referenced_by_track_elements_log_file_paths.cs
 create mode 100644 web-accessibility/develop-command-line-tool-accepting-input-path-and-output-format-arguments-perform-validation-on-demand.cs
 create mode 100644 web-accessibility/embed-validation-results-string-into-email-body-notify-stakeholders-accessibility-status.cs
 create mode 100644 web-accessibility/embed-vtt-caption-file-into-html-document-and-reference-via-newly-created-track-element.cs
 delete mode 100644 web-accessibility/embed_vtt_caption_file_into_html_document_and_reference_with_new_track_element.cs
 create mode 100644 web-accessibility/ensure-caption-tracks-contain-synchronized-timestamps-matching-associated-media-timeline.cs
 delete mode 100644 web-accessibility/ensure_caption_tracks_contain_synchronized_timestamps_matching_associated_media_timeline.cs
 rename web-accessibility/{configure_accessibilityvalidator_custom_settings_before_validating_html_document_application.cs => exclude-keyboard-navigation-warnings-from-final-report-using-result-filtering-option.cs} (52%)
 delete mode 100644 web-accessibility/exclude_keyboard_navigation_warnings_from_final_report_apply_result_filtering_option.cs
 rename web-accessibility/{check_missing_track_elements_kind_captions_in_video_tags_using_validation_report.cs => execute-validate-method-assess-multimedia-accessibility-loaded-html-document.cs} (62%)
 rename web-accessibility/{create_static_accessibilityvalidator_instance_and_reuse_to_validate_multiple_html_files_efficiently.cs => execute-validator-validate-with-file-path-to-run-accessibility-checks-on-page.cs} (58%)
 delete mode 100644 web-accessibility/execute_validate_method_assess_multimedia_accessibility_loaded_html_document.cs
 delete mode 100644 web-accessibility/execute_validator_validate_with_file_path_to_run_accessibility_checks_on_page.cs
 create mode 100644 web-accessibility/export-validation-results-formatted-string-save-to-string-developer-review.cs
 delete mode 100644 web-accessibility/export_validation_results_formatted_string_developer_review.cs
 create mode 100644 web-accessibility/fail-build-if-critical-accessibility-errors-detected-enforce-quality-gates.cs
 create mode 100644 web-accessibility/fail-ci-build-when-validationresult-contains-error-level-findings-to-enforce-accessibility-standards.cs
 delete mode 100644 web-accessibility/fail_build_if_critical_accessibility_errors_detected_enforce_quality_gates.cs
 delete mode 100644 web-accessibility/fail_ci_build_validationresult_contains_error_level_findings_enforce_accessibility_standards.cs
 rename web-accessibility/{use_accessibilityrules_getall_fetch_all_wcag_rule_codes_and_descriptions_for_ui_display.cs => fetch-all-wcag-rule-codes-and-descriptions-for-ui-display-using-accessibilityrules-getall.cs} (59%)
 create mode 100644 web-accessibility/fetch-html-content-list-urls-validate-each-page-save-results-xml-files.cs
 delete mode 100644 web-accessibility/fetch_html_content_url_list_validate_pages_save_results_xml_files.cs
 rename web-accessibility/{embed_validation_results_string_into_email_body_notify_stakeholders_accessibility_status.cs => filter-errors-by-target-types-to-separate-html-element-issues-from-css-related-problems.cs} (57%)
 create mode 100644 web-accessibility/filter-rule-set-error-level-criteria-before-validation-critical-problems.cs
 create mode 100644 web-accessibility/filter-validation-results-audio-description-warnings-targeted-video-improvements.cs
 create mode 100644 web-accessibility/filter-validation-results-display-only-caption-related-warnings-focused-remediation-efforts.cs
 create mode 100644 web-accessibility/filter-warnings-specific-ruleid-values-focus-particular-accessibility-techniques.cs
 delete mode 100644 web-accessibility/filter_errors_by_target_type_separate_html_element_issues_from_css_problems.cs
 delete mode 100644 web-accessibility/filter_rule_set_include_only_error_level_criteria_before_validation_focus_critical_problems.cs
 delete mode 100644 web-accessibility/filter_validation_results_audio_description_warnings_video_improvements.cs
 delete mode 100644 web-accessibility/filter_validation_results_display_only_caption_related_warnings_focused_remediation.cs
 delete mode 100644 web-accessibility/filter_warnings_by_specific_ruleid_values_to_focus_particular_accessibility_techniques.cs
 create mode 100644 web-accessibility/generate-detailed-validation-report-json-format-save-specified-output-directory.cs
 create mode 100644 web-accessibility/generate-markdown-report-validationresult-post-pull-request-comments.cs
 rename web-accessibility/{call_validationresult_savetostring_obtain_formatted_string_errors_warnings.cs => generate-plain-text-summary-validation-findings-quick-review-developers.cs} (57%)
 create mode 100644 web-accessibility/generate-summary-report-aggregates-total-errors-across-all-processed-html-documents-batch.cs
 delete mode 100644 web-accessibility/generate_markdown_report_from_validationresult_to_post_in_pull_request_comments.cs
 create mode 100644 web-accessibility/identify-video-elements-lacking-audio-description-tracks-filtering-validation-messages-description-warnings.cs
 delete mode 100644 web-accessibility/identify_video_elements_lacking_audio_description_tracks_by_filtering_validation_messages_for_description_warnings.cs
 create mode 100644 web-accessibility/implement-retry-mechanism-when-validating-remote-html-content-may-experience-transient-network-failures.cs
 create mode 100644 web-accessibility/incorporate-color-contrast-verification-results-into-overall-validation-summary-for-comprehensive-reporting.cs
 delete mode 100644 web-accessibility/incorporate_color_contrast_verification_results_into_overall_validation_summary_for_comprehensive_reporting.cs
 create mode 100644 web-accessibility/initialize-html-document-from-file-path-and-validate-with-default-validator.cs
 delete mode 100644 web-accessibility/initialize_htmldocument_from_file_path_and_validate_using_default_validator.cs
 create mode 100644 web-accessibility/inject-accessibilityvalidator-dependency-injection-enable-flexible-configuration-aspnet-core-applications.cs
 delete mode 100644 web-accessibility/inject_accessibilityvalidator_dependency_injection_enable_flexible_configuration_aspnet_core_applications.cs
 create mode 100644 web-accessibility/instantiate-accessibility-validator-using-createvalidator-before-loading-html-document.cs
 delete mode 100644 web-accessibility/instantiate_accessibilityvalidator_using_createvalidator_before_loading_any_html_document.cs
 rename web-accessibility/{verify_each_track_element_includes_valid_srclang_attribute_for_accessibility_standards.cs => integrate-accessibility-validation-aspose-html-workflows-multimedia-processing-pipeline.cs} (60%)
 create mode 100644 web-accessibility/integrate-validation-step-into-ci-cd-pipeline-using-command-line-invocation-validator.cs
 create mode 100644 web-accessibility/integrate-validation-step-into-github-actions-workflow-automatically-test-pull-requests.cs
 delete mode 100644 web-accessibility/integrate_validation_step_into_github_actions_workflow_to_automatically_test_pull_requests.cs
 create mode 100644 web-accessibility/iterate-accessibility-rules-advisory-techniques-list-improvement-suggestions-each-identified-issue.cs
 create mode 100644 web-accessibility/iterate-through-validationresult-details-log-rule-identifier-pass-fail-status.cs
 delete mode 100644 web-accessibility/iterate_accessibility_rules_advisory_techniques_list_improvement_suggestions_each_identified_issue.cs
 delete mode 100644 web-accessibility/iterate_through_validationresult_details_to_log_each_rule_identifier_and_its_pass_or_fail_status.cs
 create mode 100644 web-accessibility/load-html-content-from-string-variable-into-validator-in-memory-validation-scenarios.cs
 create mode 100644 web-accessibility/load-html-content-string-create-document-object-run-accessibility-validation.cs
 create mode 100644 web-accessibility/load-html-file-from-disk-into-validator-using-load-method-with-file-path-argument.cs
 create mode 100644 web-accessibility/load-html-file-local-path-into-validator-wcag-analysis.cs
 create mode 100644 web-accessibility/load-html-from-stream-into-validator-supporting-network-or-memorybased-sources.cs
 delete mode 100644 web-accessibility/load_html_from_stream_object_into_validator_support_network_memory_sources.cs
 create mode 100644 web-accessibility/log-all-validation-messages-to-file-for-further-analysis-and-troubleshooting-by-developers.cs
 create mode 100644 web-accessibility/modify-video-elements-include-keyboard-focusable-controls-add-tabindex-attributes-needed.cs
 create mode 100644 web-accessibility/prioritize-remediation-tasks-severity-levels-advisory-technique-impact-scores.cs
 create mode 100644 web-accessibility/process-batch-html-files-folder-validating-each-file-sequentially-aggregating-results.cs
 create mode 100644 web-accessibility/process-html-files-in-parallel-using-task-parallel-library-improve-validation-throughput-large-projects.cs
 create mode 100644 web-accessibility/process-html-folder-validate-each-output-individual-json-reports-target-directory.cs
 delete mode 100644 web-accessibility/process_batch_html_files_in_folder_validating_each_file_sequentially_aggregating_results.cs
 delete mode 100644 web-accessibility/process_html_files_parallel_using_task_parallel_library_improve_validation_throughput_large_projects.cs
 delete mode 100644 web-accessibility/process_html_folder_validate_each_output_individual_json_reports_to_target_directory.cs
 rename web-accessibility/{publish_validation_summaries_to_dashboard_for_continuous_monitoring_website_accessibility_status.cs => publish-validation-summaries-to-dashboard-for-continuous-monitoring-website-accessibility-status.cs} (67%)
 create mode 100644 web-accessibility/query-specific-rule-by-code-using-accessibilityrules-getrule-show-detailed-guidance.cs
 delete mode 100644 web-accessibility/query_specific_rule_by_code_accessibilityrules_getrule_show_detailed_guidance.cs
 rename web-accessibility/{re_run_validation_after_html_modifications_confirm_previously_reported_issues_resolved.cs => re-run-validation-after-html-modifications-to-confirm-previously-reported-issues-resolved.cs} (58%)
 create mode 100644 web-accessibility/read-validationresult-description-high-level-summary-accessibility-check-outcome.cs
 delete mode 100644 web-accessibility/read_validationresult_description_obtain_high_level_summary_accessibility_check_outcome.cs
 create mode 100644 web-accessibility/redirect-console-output-validation-issues-log-file-persistent-storage.cs
 create mode 100644 web-accessibility/retrieve-contrast-ratio-values-specific-foreground-background-colors-log-any-failures.cs
 rename web-accessibility/{integrate_validation_step_into_ci_cd_pipeline_using_command_line_invocation_validator.cs => retrieve-validationresult-returned-by-validate-and-store-for-further-processing.cs} (50%)
 delete mode 100644 web-accessibility/retrieve_contrast_ratio_values_for_specific_foreground_and_background_colors_log_failures.cs
 delete mode 100644 web-accessibility/retrieve_validationresult_returned_by_validate_and_store_for_further_processing.cs
 create mode 100644 web-accessibility/run-batch-validation-on-all-html-files-in-project-folder-produce-consolidated-json-report.cs
 create mode 100644 web-accessibility/run-default-accessibility-validation-and-direct-console-output-to-debug-logger-for-development-monitoring.cs
 rename web-accessibility/{run_validation_nightly_build_process_ensure_continuous_accessibility_compliance.cs => run-validation-as-part-of-nightly-build-process-to-ensure-continuous-accessibility-compliance.cs} (59%)
 delete mode 100644 web-accessibility/run_batch_validation_on_all_html_files_in_project_folder_and_produce_consolidated_json_report.cs
 delete mode 100644 web-accessibility/run_default_accessibility_validation_direct_console_output_debug_logger_development_monitoring.cs
 create mode 100644 web-accessibility/save-complete-validation-report-to-string-using-validationresult-savetostring-method-for-later-processing.cs
 create mode 100644 web-accessibility/save-validation-results-to-json-file-for-later-analysis-and-integration-with-reporting-tools.cs
 create mode 100644 web-accessibility/save-validation-results-xml-file-compatibility-legacy-systems-workflows.cs
 delete mode 100644 web-accessibility/save_complete_validation_report_to_string_using_validationresult_savetostring_method_for_later_processing.cs
 delete mode 100644 web-accessibility/save_validation_results_to_json_file_for_later_analysis_and_integration_with_reporting_tools.cs
 create mode 100644 web-accessibility/schedule-windows-task-scheduler-job-runs-batch-validation-all-html-files-nightly.cs
 delete mode 100644 web-accessibility/schedule_windows_task_scheduler_job_runs_batch_validation_all_html_files_nightly.cs
 create mode 100644 web-accessibility/select-desired-output-format-enumeration-before-saving-results.cs
 create mode 100644 web-accessibility/serialize-validationresult-to-json-custom-serialization-for-external-integration.cs
 rename web-accessibility/{write_validation_results_to_xml_using_validationresult_saveto_xml_format.cs => serialize-validationresult-xml-custom-serialization-legacy-system-compatibility.cs} (54%)
 create mode 100644 web-accessibility/set-custom-issue-severity-threshold-only-high-priority-accessibility-problems-reported.cs
 delete mode 100644 web-accessibility/set_custom_issue_severity_threshold_high_priority_accessibility_problems.cs
 create mode 100644 web-accessibility/stream-validation-results-to-network-socket-using-custom-textwriter-for-remote-monitoring.cs
 delete mode 100644 web-accessibility/stream_validation_results_to_network_socket_using_custom_textwriter_for_remote_monitoring.cs
 create mode 100644 web-accessibility/transform-validation-json-output-using-xslt-generate-human-readable-html-report.cs
 delete mode 100644 web-accessibility/transform_validation_json_output_xslt_generate_human_readable_html_report.cs
 create mode 100644 web-accessibility/update-audio-element-include-track-element-captions-set-kind-captions-correctly.cs
 create mode 100644 web-accessibility/use-online-color-contrast-checker-api-programmatically-verify-contrast-ratios-identified-elements.cs
 create mode 100644 web-accessibility/use-stringbuilder-textwriter-capture-xml-validation-output-memory.cs
 create mode 100644 web-accessibility/use-validator-aspnet-core-controller-check-uploaded-html-files-multimedia-accessibility-before-storage.cs
 create mode 100644 web-accessibility/use-validator-azure-devops-pipeline-task-publish-validation-report-build-artifact.cs
 create mode 100644 web-accessibility/use-validator-console-application-process-list-html-file-paths-command-line-arguments.cs
 rename web-accessibility/{create_validator_instance_using_createvalidator_before_loading_html_document_for_accessibility.cs => use-validator-in-github-actions-workflow-to-automatically-fail-builds-on-caption-issues-detection.cs} (69%)
 create mode 100644 web-accessibility/use-validator-within-unit-test-assert-no-multimedia-accessibility-issues-sample-html.cs
 delete mode 100644 web-accessibility/use_online_color_contrast_checker_api_programmatically_verify_contrast_ratios_identified_elements.cs
 delete mode 100644 web-accessibility/use_stringbuilder_textwriter_capture_xml_validation_output_in_memory.cs
 delete mode 100644 web-accessibility/use_validator_within_unit_test_assert_no_multimedia_accessibility_issues_in_sample_html.cs
 create mode 100644 web-accessibility/validate-html-documents-retrieved-from-remote-url-loading-content-into-validator.cs
 create mode 100644 web-accessibility/validate-html-generated-razor-view-runtime-log-accessibility-issues.cs
 delete mode 100644 web-accessibility/validate_html_documents_retrieved_from_remote_url_loading_content_into_validator.cs
 create mode 100644 web-accessibility/verify-each-track-element-includes-valid-srclang-attribute-accessibility-standards.cs
 create mode 100644 web-accessibility/write-formatted-validation-string-to-text-file-archival-reporting.cs
 create mode 100644 web-accessibility/write-method-return-warning-counts-grouped-by-target-element-type-analysis.cs
 create mode 100644 web-accessibility/write-method-returns-list-error-messages-specified-rule-identifier.cs
 create mode 100644 web-accessibility/write-validation-results-to-json-file-using-validationresult-savetojson-format.cs
 create mode 100644 web-accessibility/write-validation-results-to-xml-file-using-validationresult-savetoxml-format.cs
 delete mode 100644 web-accessibility/write_method_returning_error_messages_for_rule_identifier.cs
 delete mode 100644 web-accessibility/write_method_returns_warning_counts_grouped_target_element_type_analysis.cs

diff --git a/web-accessibility/access-validationresult-errors-collection-count-total-accessibility-errors-document.cs b/web-accessibility/access-validationresult-errors-collection-count-total-accessibility-errors-document.cs
new file mode 100644
index 0000000..ebaa2f4
--- /dev/null
+++ b/web-accessibility/access-validationresult-errors-collection-count-total-accessibility-errors-document.cs
@@ -0,0 +1,37 @@
+// Access ValidationResult.Errors collection to count total accessibility errors found in the document.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><img src='image.jpg'></body></html>";
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank");
+
+            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);
+
+            int totalErrors = 0;
+            foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+            {
+                if (!ruleResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                    {
+                        totalErrors++;
+                    }
+                }
+            }
+
+            Console.WriteLine("Total accessibility errors: " + totalErrors);
+        }
+        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/access-validationresult-warnings-collection-count-total-accessibility-warnings-html-page.cs
similarity index 52%
rename from web-accessibility/generate_plain_text_summary_validation_findings_review_developers.cs
rename to web-accessibility/access-validationresult-warnings-collection-count-total-accessibility-warnings-html-page.cs
index 8a71fb6..a1a6ae3 100644
--- a/web-accessibility/generate_plain_text_summary_validation_findings_review_developers.cs
+++ b/web-accessibility/access-validationresult-warnings-collection-count-total-accessibility-warnings-html-page.cs
@@ -1,7 +1,10 @@
-// Generate a plain‑text summary of validation findings for quick review by developers.
+// Access ValidationResult.Warnings collection to count total accessibility warnings reported for the HTML page.
 
 using System;
 using System.IO;
+using Aspose.Html;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
 
 class Program
 {
@@ -9,30 +12,29 @@ 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);
+            // Prepare a minimal HTML file
+            string htmlPath = "sample.html";
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Sample</h1></body></html>";
+            File.WriteAllText(htmlPath, htmlContent);
 
             // Load the HTML document
-            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath))
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlPath))
             {
-                // Create WebAccessibility and validator
+                // 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);
 
+                // Count total warnings (if the API exposed a Warnings collection, it would be used here)
+                int warningsCount = 0;
+                // The current API version does not provide a direct Warnings collection on ValidationResult.
+                // If needed, warnings could be derived from detailed results in future versions.
+
+                Console.WriteLine($"Validation Success: {validationResult.Success}");
+                Console.WriteLine($"Total Warnings: {warningsCount}");
+
                 if (!validationResult.Success)
                 {
                     foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
@@ -42,28 +44,16 @@ static void Main()
                             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)
+                                Console.WriteLine($"Error: {techResult.Error.ErrorMessage}");
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
                                 {
-                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)error.Target.Item;
-                                    Console.WriteLine($"  Element HTML: {element.OuterHTML}");
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)techResult.Error.Target.Item;
+                                    Console.WriteLine($"Element: {element.OuterHTML}");
                                 }
                             }
                         }
                     }
                 }
-                else
-                {
-                    Console.WriteLine("Document passed accessibility validation.");
-                }
-            }
-
-            // Clean up temporary file
-            if (File.Exists(inputPath))
-            {
-                File.Delete(inputPath);
             }
         }
         catch (Exception ex)
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
deleted file mode 100644
index 9303df4..0000000
--- a/web-accessibility/access_validationresult_errors_collection_count_total_accessibility_errors_found_document.cs
+++ /dev/null
@@ -1,65 +0,0 @@
-// 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/add-missing-track-element-with-kind-captions-and-appropriate-src-to-video-programmatically.cs b/web-accessibility/add-missing-track-element-with-kind-captions-and-appropriate-src-to-video-programmatically.cs
new file mode 100644
index 0000000..34d0713
--- /dev/null
+++ b/web-accessibility/add-missing-track-element-with-kind-captions-and-appropriate-src-to-video-programmatically.cs
@@ -0,0 +1,58 @@
+// Add a missing <track> element with kind="captions" and appropriate src attribute to a video element programmatically.
+
+using System;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Collections;
+using Aspose.Html.Dom;
+using Aspose.Html.Saving;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            // Prepare sample HTML content with a video element lacking a track
+            string htmlContent = "<!DOCTYPE html><html><body><video id='myVideo' src='movie.mp4'></video></body></html>";
+
+            // Load the HTML document from the string (use two‑argument constructor)
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank");
+
+            // Find all <video> elements
+            Aspose.Html.Collections.HTMLCollection videos = document.GetElementsByTagName("video");
+
+            for (int i = 0; i < videos.Length; i++)
+            {
+                Aspose.Html.Dom.Element videoElement = videos[i] as Aspose.Html.Dom.Element;
+                if (videoElement == null)
+                    continue;
+
+                // Create a <track> element for captions
+                Aspose.Html.Dom.Element trackElement = document.CreateElement("track");
+                trackElement.SetAttribute("kind", "captions");
+                trackElement.SetAttribute("src", "captions.vtt");
+                trackElement.SetAttribute("srclang", "en");
+                trackElement.SetAttribute("label", "English");
+
+                // Append the track to the video element
+                videoElement.AppendChild(trackElement);
+            }
+
+            // Prepare output directory and file path
+            string outputDir = Path.Combine(Directory.GetCurrentDirectory(), "Output");
+            Directory.CreateDirectory(outputDir);
+            string outputPath = Path.Combine(outputDir, "result.html");
+
+            // Save the modified document
+            Aspose.Html.Saving.HTMLSaveOptions saveOptions = new Aspose.Html.Saving.HTMLSaveOptions();
+            document.Save(outputPath, saveOptions);
+
+            Console.WriteLine("Document saved to: " + outputPath);
+        }
+        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
deleted file mode 100644
index d9c9405..0000000
--- a/web-accessibility/add_missing_track_element_with_kind_captions_and_src_to_video_programmatically.cs
+++ /dev/null
@@ -1,135 +0,0 @@
-// 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-validation-graceful-termination-batch-runs.cs b/web-accessibility/apply-cancellation-token-validation-graceful-termination-batch-runs.cs
new file mode 100644
index 0000000..984d81c
--- /dev/null
+++ b/web-accessibility/apply-cancellation-token-validation-graceful-termination-batch-runs.cs
@@ -0,0 +1,63 @@
+// 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.Threading.Tasks;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            // Prepare sample input folder and file
+            string inputFolder = "InputHtml";
+            Directory.CreateDirectory(inputFolder);
+            string sampleFile = Path.Combine(inputFolder, "sample.html");
+            if (!File.Exists(sampleFile))
+            {
+                File.WriteAllText(sampleFile, "<!DOCTYPE html><html><head><title>Sample</title></head><body><p>Hello World</p></body></html>");
+            }
+
+            // Cancellation token that triggers after 10 seconds
+            using (CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(10)))
+            {
+                string[] htmlFiles = Directory.GetFiles(inputFolder, "*.html");
+                foreach (string filePath in htmlFiles)
+                {
+                    if (cts.Token.IsCancellationRequested)
+                    {
+                        Console.WriteLine("Operation cancelled before processing file: " + Path.GetFileName(filePath));
+                        break;
+                    }
+
+                    ValidateHtml(filePath, cts.Token);
+                }
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            Console.WriteLine("Validation was cancelled.");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+
+    static void ValidateHtml(string filePath, CancellationToken token)
+    {
+        // Load the HTML document (simulating validation)
+        Aspose.Html.Configuration configuration = new Aspose.Html.Configuration();
+        using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(filePath, configuration))
+        {
+            // Simple validation logic: access the title
+            string title = document.Title;
+            Console.WriteLine($"Validated '{Path.GetFileName(filePath)}' - Title: {title}");
+        }
+
+        // Check for cancellation after processing
+        token.ThrowIfCancellationRequested();
+    }
+}
\ 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..32e6b0c
--- /dev/null
+++ b/web-accessibility/call-validationresult-savetostring-obtain-formatted-string-errors-warnings.cs
@@ -0,0 +1,25 @@
+// Call ValidationResult.SaveToString to obtain a formatted string of errors and warnings.
+
+namespace MyApp
+{
+    class Program
+    {
+        static void Main()
+        {
+            try
+            {
+                string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>";
+                Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank");
+                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);
+                string resultString = validationResult.SaveToString();
+                System.Console.WriteLine(resultString);
+            }
+            catch (System.Exception ex)
+            {
+                System.Console.WriteLine("Error: " + 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..430a736
--- /dev/null
+++ b/web-accessibility/check-missing-track-elements-kind-captions-in-video-tags-using-validation-report.cs
@@ -0,0 +1,57 @@
+// Check for missing <track> elements with kind="captions" in video tags using the validation report.
+
+namespace Example
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            try
+            {
+                string htmlContent = "<!DOCTYPE html><html><body>" +
+                    "<video src='movie.mp4' controls></video>" +
+                    "<video src='movie2.mp4' controls>" +
+                    "<track kind='captions' src='captions.vtt' srclang='en' label='English'></track>" +
+                    "</video>" +
+                    "</body></html>";
+
+                Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank");
+
+                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 src = element.GetAttribute("src");
+                                    System.Console.WriteLine($"Tag: {tagName}, src: {src}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    System.Console.WriteLine("No accessibility issues found.");
+                }
+
+                document.Dispose();
+            }
+            catch (System.Exception ex)
+            {
+                System.Console.WriteLine($"Error: {ex.Message}");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/combine-validation-seo-metrics-identify-pages-accessibility-ranking-issues.cs b/web-accessibility/combine-validation-seo-metrics-identify-pages-accessibility-ranking-issues.cs
new file mode 100644
index 0000000..52a81a7
--- /dev/null
+++ b/web-accessibility/combine-validation-seo-metrics-identify-pages-accessibility-ranking-issues.cs
@@ -0,0 +1,103 @@
+// Combine validation findings with SEO metrics to identify pages with both accessibility and ranking issues.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+using Aspose.Html;
+
+namespace AsposeHtmlAccessibilitySeoExample
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            try
+            {
+                // Sample URLs to validate
+                List<string> urls = new List<string>
+                {
+                    "https://example.com/page1.html",
+                    "https://example.com/page2.html"
+                };
+
+                // Simulated SEO scores for each URL
+                Dictionary<string, double> seoScores = new Dictionary<string, double>
+                {
+                    { "https://example.com/page1.html", 45.0 },
+                    { "https://example.com/page2.html", 80.0 }
+                };
+
+                double rankingThreshold = 50.0; // Scores below this are considered low
+
+                // Initialize accessibility validator
+                WebAccessibility webAccessibility = new WebAccessibility();
+                AccessibilityValidator validator = webAccessibility.CreateValidator(ValidationBuilder.All);
+
+                int index = 1;
+                foreach (string url in urls)
+                {
+                    using (HTMLDocument document = new HTMLDocument(url))
+                    {
+                        ValidationResult validationResult = validator.Validate(document);
+                        bool hasAccessibilityIssues = !validationResult.Success;
+
+                        // Output accessibility error details if any
+                        if (hasAccessibilityIssues)
+                        {
+                            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;
+                                            string id = element.GetAttribute("id");
+                                            Console.WriteLine($"Accessibility Issue - Tag: {tagName}, Id: {id}, Message: {techResult.Error.ErrorMessage}");
+                                        }
+                                        else
+                                        {
+                                            Console.WriteLine($"Accessibility Issue - Message: {techResult.Error.ErrorMessage}");
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
+                        // Determine SEO issue
+                        double seoScore = 0;
+                        bool hasSeoIssue = seoScores.TryGetValue(url, out seoScore) && seoScore < rankingThreshold;
+
+                        // Combine results
+                        if (hasAccessibilityIssues && hasSeoIssue)
+                        {
+                            Console.WriteLine($"Page {index}: {url} has accessibility issues and low SEO score ({seoScore}).");
+                        }
+                        else if (hasAccessibilityIssues)
+                        {
+                            Console.WriteLine($"Page {index}: {url} has accessibility issues (SEO score {seoScore}).");
+                        }
+                        else if (hasSeoIssue)
+                        {
+                            Console.WriteLine($"Page {index}: {url} has low SEO score ({seoScore}) but no accessibility issues.");
+                        }
+                        else
+                        {
+                            Console.WriteLine($"Page {index}: {url} passes both checks (SEO score {seoScore}).");
+                        }
+                    }
+
+                    index++;
+                }
+            }
+            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
deleted file mode 100644
index f163736..0000000
--- a/web-accessibility/combine_validation_findings_with_seo_metrics_to_identify_pages_with_accessibility_and_ranking_issues.cs
+++ /dev/null
@@ -1,79 +0,0 @@
-// 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..41e4b9b
--- /dev/null
+++ b/web-accessibility/compare-two-validationresult-objects-detect-regressions-after-modifying-html-content-same-project.cs
@@ -0,0 +1,64 @@
+// Compare two ValidationResult objects to detect regressions after modifying HTML content in the same project.
+
+using System;
+
+namespace Example
+{
+    class Program
+    {
+        static void Main()
+        {
+            try
+            {
+                // Original HTML content
+                string originalHtml = "<!DOCTYPE html><html><head><title>Original</title></head><body><h1>Hello</h1></body></html>";
+                // Modified HTML content (potential regression)
+                string modifiedHtml = "<!DOCTYPE html><html><head><title>Modified</title></head><body><h1>Hello</h1><img src='missing.jpg'></body></html>";
+
+                // Create WebAccessibility instance
+                var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+                // Create a validator that checks all rules
+                var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+                // Validate original HTML
+                var documentOriginal = new Aspose.Html.HTMLDocument(originalHtml, "about:blank");
+                Aspose.Html.Accessibility.Results.ValidationResult originalResult = validator.Validate(documentOriginal);
+
+                // Validate modified HTML
+                var documentModified = new Aspose.Html.HTMLDocument(modifiedHtml, "about:blank");
+                Aspose.Html.Accessibility.Results.ValidationResult modifiedResult = validator.Validate(documentModified);
+
+                // Compare validation results to detect regressions
+                foreach (Aspose.Html.Accessibility.Results.RuleValidationResult originalRule in originalResult.Details)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult modifiedRule in modifiedResult.Details)
+                    {
+                        if (originalRule.Rule.Code == modifiedRule.Rule.Code)
+                        {
+                            // Regression: previously successful rule now fails
+                            if (originalRule.Success && !modifiedRule.Success)
+                            {
+                                Console.WriteLine("Regression detected: " + modifiedRule.Rule.Code + " - " + modifiedRule.Rule.Description);
+                                foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in modifiedRule.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);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            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
deleted file mode 100644
index 0dbbbf3..0000000
--- a/web-accessibility/compare_two_validationresult_objects_detect_regressions_after_modifying_html_content_same_project.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-// 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-accessibility-validator-with-custom-settings-before-validating-html-document-in-application.cs b/web-accessibility/configure-accessibility-validator-with-custom-settings-before-validating-html-document-in-application.cs
new file mode 100644
index 0000000..c0fef65
--- /dev/null
+++ b/web-accessibility/configure-accessibility-validator-with-custom-settings-before-validating-html-document-in-application.cs
@@ -0,0 +1,54 @@
+// Configure an AccessibilityValidator with custom settings before validating an HTML document in the application.
+
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            // Initialize WebAccessibility
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+            // Configure custom validation settings: select a specific principle and guideline
+            Aspose.Html.Accessibility.Principle principle = webAccessibility.Rules.GetPrinciple("WCAG2AA");
+            Aspose.Html.Accessibility.Guideline guideline = principle.GetGuideline("1.1.1");
+
+            // Create validator with the selected guideline and all validation options
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(guideline, Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><img src=\"image.png\" alt=\"\"></body></html>";
+
+            // Load HTML document from inline content
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (validationResult.Success)
+                {
+                    System.Console.WriteLine("Document is accessible.");
+                }
+                else
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                System.Console.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Console.WriteLine($"Error: {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/configure-validator-ignore-selected-rule-codes-allowing-custom-compliance-thresholds-during-checks.cs
similarity index 56%
rename from web-accessibility/load_html_file_from_local_path_into_validator_for_wcag_analysis.cs
rename to web-accessibility/configure-validator-ignore-selected-rule-codes-allowing-custom-compliance-thresholds-during-checks.cs
index 2c9b620..93db859 100644
--- a/web-accessibility/load_html_file_from_local_path_into_validator_for_wcag_analysis.cs
+++ b/web-accessibility/configure-validator-ignore-selected-rule-codes-allowing-custom-compliance-thresholds-during-checks.cs
@@ -1,7 +1,7 @@
-// Load an HTML file from a local path into the validator for WCAG analysis.
+// Configure the validator to ignore selected rule codes, allowing custom compliance thresholds during checks.
 
 using System;
-using System.Drawing;
+using System.IO;
 
 class Program
 {
@@ -11,33 +11,46 @@ static void Main()
         {
             // Sample HTML content
             string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>";
+            // Load HTML document from inline content
+            var document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank");
 
-            // Initialize WebAccessibility and create a validator for all rules
+            // 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 HTML document from the string literal
-            var document = new Aspose.Html.HTMLDocument(htmlContent);
+            // Define rule codes to ignore
+            string[] ignoredRuleCodes = new string[]
+            {
+                "WCAG2AA.Principle1.Guideline1_1.1_1_1", // example rule code
+                "WCAG2AA.Principle2.Guideline2_4.2_4_2"  // another example
+            };
 
             // 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
+            // Process validation results, skipping ignored rules
+            if (!validationResult.Success)
             {
-                Console.WriteLine("Accessibility validation failed. Details:");
                 foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
                 {
+                    if (Array.IndexOf(ignoredRuleCodes, detail.Rule.Code) >= 0)
+                    {
+                        // Skip ignored rule
+                        continue;
+                    }
+
                     Console.WriteLine($"Rule Code: {detail.Rule.Code}");
                     Console.WriteLine($"Description: {detail.Rule.Description}");
                     Console.WriteLine($"Success: {detail.Success}");
                     Console.WriteLine(new string('-', 40));
                 }
             }
+            else
+            {
+                Console.WriteLine("Document passed all validation checks (excluding ignored rules).");
+            }
         }
         catch (Exception ex)
         {
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..52727c2
--- /dev/null
+++ b/web-accessibility/configure-validator-treat-caption-missing-warnings-as-errors-adjust-severity-settings.cs
@@ -0,0 +1,53 @@
+// Configure the validator to treat caption missing warnings as errors by adjusting severity settings.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content with a table missing a caption
+            string htmlContent = "<html><body><table><tr><td>Data</td></tr></table></body></html>";
+
+            // Create a WebAccessibility instance
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+            // Create a validator that includes all rules
+            var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load the HTML content (use two‑argument constructor to avoid file‑path interpretation)
+            using (var document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (validationResult.Success)
+                {
+                    Console.WriteLine("Validation succeeded: no accessibility issues found.");
+                }
+                else
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        // Treat missing caption warnings as errors
+                        bool isCaptionMissingWarning = string.Equals(ruleResult.Rule.Code, "CaptionMissing", StringComparison.OrdinalIgnoreCase);
+
+                        if (!ruleResult.Success || isCaptionMissingWarning)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                Console.WriteLine($"Error: {techResult.Error.ErrorMessage}");
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"An exception occurred: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/configure-validator-use-static-rule-repository-consistent-rule-application-across-runs.cs b/web-accessibility/configure-validator-use-static-rule-repository-consistent-rule-application-across-runs.cs
new file mode 100644
index 0000000..7c6c6c9
--- /dev/null
+++ b/web-accessibility/configure-validator-use-static-rule-repository-consistent-rule-application-across-runs.cs
@@ -0,0 +1,47 @@
+// Configure the validator to use a static rule repository for consistent rule application across runs.
+
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            // Initialize WebAccessibility
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+            // Create a validator that uses the static rule repository (all rules)
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>";
+
+            // Load HTML document from inline content (use two‑argument constructor)
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank");
+
+            // Perform validation
+            Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+            // Process validation results
+            if (!validationResult.Success)
+            {
+                foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                {
+                    Console.WriteLine($"Rule: {detail.Rule.Code}");
+                    Console.WriteLine($"Description: {detail.Rule.Description}");
+                    Console.WriteLine($"Success: {detail.Success}");
+                    Console.WriteLine(new string('-', 40));
+                }
+            }
+            else
+            {
+                Console.WriteLine("Document passed all accessibility checks.");
+            }
+        }
+        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
deleted file mode 100644
index fadb359..0000000
--- a/web-accessibility/configure_validator_static_rule_repository_consistent_rule_application_across_runs.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-// 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
deleted file mode 100644
index 9be2bab..0000000
--- a/web-accessibility/configure_validator_treat_caption_missing_warnings_as_errors_adjust_severity_settings.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// 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-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..0296dbb
--- /dev/null
+++ b/web-accessibility/create-powershell-script-loads-dotnet-library-validates-html-file-prints-json-results.cs
@@ -0,0 +1,38 @@
+// Create a PowerShell script that loads the .NET library, validates an HTML file, and prints JSON results.
+
+using System;
+using System.IO;
+
+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>");
+            }
+
+            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(inputPath))
+            {
+                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.JSON);
+                    string json = sw.ToString();
+                    Console.WriteLine(json);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/create-rule-subset-wcag-criteria-from-accessibilityrules-before-validation.cs b/web-accessibility/create-rule-subset-wcag-criteria-from-accessibilityrules-before-validation.cs
new file mode 100644
index 0000000..bd0c497
--- /dev/null
+++ b/web-accessibility/create-rule-subset-wcag-criteria-from-accessibilityrules-before-validation.cs
@@ -0,0 +1,74 @@
+// Create a custom rule subset by selecting specific WCAG criteria from AccessibilityRules before validation.
+
+using System;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+using Aspose.Html;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Welcome</h1></body></html>";
+
+            // Initialize WebAccessibility
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+            // Select a specific WCAG criterion (example: Perceivable principle, Guideline 1.1, Criterion 1.1.1)
+            var principle = webAccessibility.Rules.GetPrinciple("Perceivable");
+            var guideline = principle?.GetGuideline("1.1");
+            var criterion = guideline?.GetCriterion("1.1.1");
+
+            if (criterion != null)
+            {
+                Console.WriteLine("{0}:{1} - {2}", criterion.Code, criterion.Description, criterion.Level);
+                foreach (IRule technique in criterion.SufficientTechniques)
+                {
+                    Console.WriteLine("{0}:{1}", technique.Code, technique.Description);
+                }
+            }
+            else
+            {
+                Console.WriteLine("Specified criterion not found. Proceeding with full validation.");
+            }
+
+            // Create validator (using all rules for demonstration)
+            var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load HTML document from string (using two-argument constructor)
+            using (var document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                // Perform validation
+                ValidationResult validationResult = validator.Validate(document);
+
+                if (validationResult.Success)
+                {
+                    Console.WriteLine("Accessibility validation succeeded. No issues found.");
+                }
+                else
+                {
+                    foreach (RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    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-static-accessibilityvalidator-instance-reuse-validate-multiple-html-files-efficiently.cs b/web-accessibility/create-static-accessibilityvalidator-instance-reuse-validate-multiple-html-files-efficiently.cs
new file mode 100644
index 0000000..bfd0222
--- /dev/null
+++ b/web-accessibility/create-static-accessibilityvalidator-instance-reuse-validate-multiple-html-files-efficiently.cs
@@ -0,0 +1,63 @@
+// Create a static AccessibilityValidator instance and reuse it to validate multiple HTML files efficiently.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+using Aspose.Html;
+
+class Program
+{
+    private static readonly AccessibilityValidator validator = new WebAccessibility().CreateValidator(ValidationBuilder.All);
+
+    static void Main()
+    {
+        try
+        {
+            // Prepare sample HTML files
+            string inputDir = Path.Combine(Directory.GetCurrentDirectory(), "HTMLSamples");
+            Directory.CreateDirectory(inputDir);
+
+            string file1 = Path.Combine(inputDir, "sample1.html");
+            string file2 = Path.Combine(inputDir, "sample2.html");
+
+            File.WriteAllText(file1, "<!DOCTYPE html><html><head><title>Sample 1</title></head><body><h1>Test 1</h1></body></html>");
+            File.WriteAllText(file2, "<!DOCTYPE html><html><head><title>Sample 2</title></head><body><img src=\"missing.jpg\" alt=\"\"/></body></html>");
+
+            List<string> htmlFiles = new List<string> { file1, file2 };
+
+            int index = 1;
+            foreach (string htmlPath in htmlFiles)
+            {
+                using (HTMLDocument document = new HTMLDocument(htmlPath))
+                {
+                    ValidationResult validationResult = validator.Validate(document);
+                    if (validationResult.Success)
+                    {
+                        Console.WriteLine($"File {index}: Validation succeeded.");
+                    }
+                    else
+                    {
+                        Console.WriteLine($"File {index}: Validation failed with the following errors:");
+                        foreach (RuleValidationResult ruleResult in validationResult.Details)
+                        {
+                            if (!ruleResult.Success)
+                            {
+                                foreach (ITechniqueResult techResult in ruleResult.Errors)
+                                {
+                                    Console.WriteLine(techResult.Error.ErrorMessage);
+                                }
+                            }
+                        }
+                    }
+                }
+                index++;
+            }
+        }
+        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-accessibility.cs b/web-accessibility/create-validator-instance-using-createvalidator-before-loading-html-document-accessibility.cs
new file mode 100644
index 0000000..2fb31db
--- /dev/null
+++ b/web-accessibility/create-validator-instance-using-createvalidator-before-loading-html-document-accessibility.cs
@@ -0,0 +1,48 @@
+// Create a validator instance using CreateValidator() before loading any HTML document for accessibility.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Create WebAccessibility and validator before loading the document
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1></body></html>";
+
+            // Load HTML document from string (using two-argument constructor)
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                // Perform accessibility validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (validationResult.Success)
+                {
+                    System.Console.WriteLine("Document is accessible.");
+                }
+                else
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                System.Console.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Console.WriteLine("An error occurred: " + 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
deleted file mode 100644
index e00f468..0000000
--- a/web-accessibility/create_custom_rule_subset_selecting_specific_wcag_criteria_from_accessibilityrules_before_validation.cs
+++ /dev/null
@@ -1,91 +0,0 @@
-// 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/detect-absent-caption-files-referenced-track-elements-log-file-paths.cs b/web-accessibility/detect-absent-caption-files-referenced-track-elements-log-file-paths.cs
new file mode 100644
index 0000000..2fa5173
--- /dev/null
+++ b/web-accessibility/detect-absent-caption-files-referenced-track-elements-log-file-paths.cs
@@ -0,0 +1,56 @@
+// Detect absent caption files referenced by <track> elements and log their file paths.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputPath = "sample.html";
+            string logPath = "missing_captions.log";
+
+            // Create a minimal sample HTML file if it does not exist
+            if (!System.IO.File.Exists(inputPath))
+            {
+                string sampleHtml = "<!DOCTYPE html><html><head><title>Test</title></head><body><video controls><track src=\"missing1.vtt\" kind=\"subtitles\" srclang=\"en\" label=\"English\"><track src=\"existing.vtt\" kind=\"subtitles\" srclang=\"en\" label=\"English\"></video></body></html>";
+                System.IO.File.WriteAllText(inputPath, sampleHtml);
+                // Create an existing caption file for demonstration
+                System.IO.File.WriteAllText("existing.vtt", "WEBVTT\n\n00:00.000 --> 00:05.000\nHello");
+            }
+
+            // Load the HTML document
+            Aspose.Html.HTMLDocument doc = new Aspose.Html.HTMLDocument(inputPath);
+
+            // Find all <track> elements
+            Aspose.Html.Dom.XPath.IXPathResult result = doc.Evaluate("//track", doc, doc.CreateNSResolver(doc), Aspose.Html.Dom.XPath.XPathResultType.Any, null);
+
+            Aspose.Html.Dom.Node node;
+            while ((node = result.IterateNext()) != null)
+            {
+                Aspose.Html.Dom.Element element = node as Aspose.Html.Dom.Element;
+                if (element != null)
+                {
+                    string src = element.GetAttribute("src");
+                    if (!string.IsNullOrEmpty(src))
+                    {
+                        // Resolve the caption file path relative to the HTML file location
+                        string baseDir = System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(inputPath));
+                        string captionPath = System.IO.Path.Combine(baseDir, src);
+                        if (!System.IO.File.Exists(captionPath))
+                        {
+                            System.IO.File.AppendAllText(logPath, captionPath + System.Environment.NewLine);
+                        }
+                    }
+                }
+            }
+
+            System.Console.WriteLine("Processing completed. Check log at " + logPath);
+        }
+        catch (System.Exception ex)
+        {
+            System.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
deleted file mode 100644
index 921a6fd..0000000
--- a/web-accessibility/detect_absent_caption_files_referenced_by_track_elements_log_file_paths.cs
+++ /dev/null
@@ -1,93 +0,0 @@
-// 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-perform-validation-on-demand.cs b/web-accessibility/develop-command-line-tool-accepting-input-path-and-output-format-arguments-perform-validation-on-demand.cs
new file mode 100644
index 0000000..9ae4a36
--- /dev/null
+++ b/web-accessibility/develop-command-line-tool-accepting-input-path-and-output-format-arguments-perform-validation-on-demand.cs
@@ -0,0 +1,53 @@
+// Develop a command‑line tool accepting input path and output format arguments to perform validation on demand.
+
+using System;
+using System.IO;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+using Aspose.Html.Accessibility.Saving;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            // Determine input HTML file path
+            string inputPath = args.Length > 0 ? args[0] : "sample.html";
+
+            // Ensure the input file exists; create a minimal sample if needed
+            if (!File.Exists(inputPath))
+            {
+                File.WriteAllText(inputPath, "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello, World!</h1></body></html>");
+            }
+
+            // Determine output format (xml or json), default to xml
+            string formatArg = args.Length > 1 ? args[1].ToLowerInvariant() : "xml";
+            ValidationResultSaveFormat saveFormat = formatArg == "json"
+                ? ValidationResultSaveFormat.JSON
+                : ValidationResultSaveFormat.XML;
+
+            // Load the HTML document
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                // Create the accessibility validator
+                WebAccessibility webAccessibility = new WebAccessibility();
+                AccessibilityValidator validator = webAccessibility.CreateValidator();
+
+                // Perform validation
+                ValidationResult result = validator.Validate(document);
+
+                // Output validation result
+                using (StringWriter sw = new StringWriter())
+                {
+                    result.SaveTo(sw, saveFormat);
+                    Console.WriteLine(sw.ToString());
+                }
+            }
+        }
+        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..e46abc9
--- /dev/null
+++ b/web-accessibility/embed-validation-results-string-into-email-body-notify-stakeholders-accessibility-status.cs
@@ -0,0 +1,40 @@
+// Embed validation results string into an email body to notify stakeholders of accessibility status.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src='image.jpg'></body></html>";
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                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);
+                string validationString = validationResult.SaveToString();
+                string emailBody = $"Accessibility validation results:\n{validationString}";
+                Console.WriteLine(emailBody);
+                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);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        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-via-newly-created-track-element.cs b/web-accessibility/embed-vtt-caption-file-into-html-document-and-reference-via-newly-created-track-element.cs
new file mode 100644
index 0000000..2368256
--- /dev/null
+++ b/web-accessibility/embed-vtt-caption-file-into-html-document-and-reference-via-newly-created-track-element.cs
@@ -0,0 +1,54 @@
+// Embed a .vtt caption file into the HTML document and reference it via a newly created <track> element.
+
+using System;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Dom;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string htmlContent = "<!DOCTYPE html><html><head><title>Video with Captions</title></head><body></body></html>";
+            HTMLDocument document = new HTMLDocument(htmlContent, "about:blank");
+            HTMLElement body = (HTMLElement)document.Body;
+
+            // Create <video> element
+            HTMLElement video = (HTMLElement)document.CreateElement("video");
+            video.SetAttribute("controls", "controls");
+            video.SetAttribute("width", "640");
+            video.SetAttribute("height", "360");
+
+            // Optional: add a <source> element for the video file
+            HTMLElement source = (HTMLElement)document.CreateElement("source");
+            source.SetAttribute("src", "sample.mp4");
+            source.SetAttribute("type", "video/mp4");
+            video.AppendChild(source);
+
+            // Create <track> element referencing the .vtt file
+            HTMLElement track = (HTMLElement)document.CreateElement("track");
+            track.SetAttribute("kind", "captions");
+            track.SetAttribute("src", "captions.vtt");
+            track.SetAttribute("srclang", "en");
+            track.SetAttribute("label", "English");
+            track.SetAttribute("default", "default");
+            video.AppendChild(track);
+
+            // Append video to the document body
+            body.AppendChild(video);
+
+            // Create a sample .vtt caption file
+            string vttContent = "WEBVTT\n\n00:00:00.000 --> 00:00:05.000\nHello, world!";
+            File.WriteAllText("captions.vtt", vttContent);
+
+            // Save the modified HTML document
+            document.Save("output.html");
+        }
+        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
deleted file mode 100644
index 8687292..0000000
--- a/web-accessibility/embed_vtt_caption_file_into_html_document_and_reference_with_new_track_element.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-// 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..0ba0fdb
--- /dev/null
+++ b/web-accessibility/ensure-caption-tracks-contain-synchronized-timestamps-matching-associated-media-timeline.cs
@@ -0,0 +1,60 @@
+// Ensure caption tracks contain synchronized timestamps matching the associated media timeline.
+
+using System;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Dom;
+using Aspose.Html.Saving;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare output directory
+            string outputDir = Path.Combine(Directory.GetCurrentDirectory(), "output");
+            Directory.CreateDirectory(outputDir);
+
+            // Create sample HTML with a video element
+            string htmlContent = "<!DOCTYPE html><html><head><meta charset=\"UTF-8\"></head><body><video id=\"vid\" controls></video></body></html>";
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank");
+
+            // Get the video element
+            Aspose.Html.Dom.Element video = document.GetElementById("vid");
+
+            // Create a track element for captions
+            Aspose.Html.Dom.Element track = document.CreateElement("track");
+            track.SetAttribute("kind", "captions");
+            track.SetAttribute("srclang", "en");
+            track.SetAttribute("label", "English");
+            track.SetAttribute("src", "captions.vtt");
+
+            // Append the track to the video element
+            video.AppendChild(track);
+
+            // Save the HTML file
+            string htmlPath = Path.Combine(outputDir, "video_with_captions.html");
+            Aspose.Html.Saving.HTMLSaveOptions saveOptions = new Aspose.Html.Saving.HTMLSaveOptions();
+            document.Save(htmlPath, saveOptions);
+
+            // Generate a simple VTT file with synchronized timestamps
+            string vttContent = "WEBVTT\n\n" +
+                                "00:00.000 --> 00:05.000\n" +
+                                "Hello World\n\n" +
+                                "00:05.000 --> 00:10.000\n" +
+                                "Second caption\n";
+
+            string vttPath = Path.Combine(outputDir, "captions.vtt");
+            File.WriteAllText(vttPath, vttContent);
+
+            Console.WriteLine("HTML and caption track files have been created successfully:");
+            Console.WriteLine(htmlPath);
+            Console.WriteLine(vttPath);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("An error occurred: " + 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
deleted file mode 100644
index e852335..0000000
--- a/web-accessibility/ensure_caption_tracks_contain_synchronized_timestamps_matching_associated_media_timeline.cs
+++ /dev/null
@@ -1,114 +0,0 @@
-// 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/configure_accessibilityvalidator_custom_settings_before_validating_html_document_application.cs b/web-accessibility/exclude-keyboard-navigation-warnings-from-final-report-using-result-filtering-option.cs
similarity index 52%
rename from web-accessibility/configure_accessibilityvalidator_custom_settings_before_validating_html_document_application.cs
rename to web-accessibility/exclude-keyboard-navigation-warnings-from-final-report-using-result-filtering-option.cs
index 3d03470..ab012b1 100644
--- a/web-accessibility/configure_accessibilityvalidator_custom_settings_before_validating_html_document_application.cs
+++ b/web-accessibility/exclude-keyboard-navigation-warnings-from-final-report-using-result-filtering-option.cs
@@ -1,8 +1,6 @@
-// Configure an AccessibilityValidator with custom settings before validating an HTML document in the application.
+// Exclude keyboard navigation warnings from the final report by applying a result‑filtering option.
 
 using System;
-using System.IO;
-using System.Text;
 
 class Program
 {
@@ -10,69 +8,55 @@ 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);
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><a href=\"#\" tabindex=\"0\">Link</a></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(tempFilePath))
+            // Load HTML document from inline content
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
             {
                 // Perform validation
                 Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
 
-                if (validationResult.Success)
+                // Process validation results, excluding keyboard navigation warnings
+                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}");
+                                // Skip warnings related to keyboard navigation
+                                if (techResult.Error.ErrorMessage != null &&
+                                    techResult.Error.ErrorMessage.IndexOf("keyboard", StringComparison.OrdinalIgnoreCase) >= 0)
+                                {
+                                    continue;
+                                }
 
-                                // 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}");
+                                    string attributeValue = element.GetAttribute("id"); // example attribute
+                                    System.Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
                                 }
                             }
                         }
                     }
                 }
-            }
-
-            // Clean up temporary file
-            if (File.Exists(tempFilePath))
-            {
-                File.Delete(tempFilePath);
+                else
+                {
+                    System.Console.WriteLine("Accessibility validation succeeded with no errors.");
+                }
             }
         }
         catch (Exception ex)
         {
-            Console.WriteLine($"An error occurred: {ex.Message}");
+            System.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
deleted file mode 100644
index 47a556c..0000000
--- a/web-accessibility/exclude_keyboard_navigation_warnings_from_final_report_apply_result_filtering_option.cs
+++ /dev/null
@@ -1,105 +0,0 @@
-// 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/check_missing_track_elements_kind_captions_in_video_tags_using_validation_report.cs b/web-accessibility/execute-validate-method-assess-multimedia-accessibility-loaded-html-document.cs
similarity index 62%
rename from web-accessibility/check_missing_track_elements_kind_captions_in_video_tags_using_validation_report.cs
rename to web-accessibility/execute-validate-method-assess-multimedia-accessibility-loaded-html-document.cs
index 9377239..13e3398 100644
--- a/web-accessibility/check_missing_track_elements_kind_captions_in_video_tags_using_validation_report.cs
+++ b/web-accessibility/execute-validate-method-assess-multimedia-accessibility-loaded-html-document.cs
@@ -1,4 +1,4 @@
-// Check for missing <track> elements with kind="captions" in video tags using the validation report.
+// Execute the Validate method to assess multimedia accessibility of the loaded HTML document.
 
 using System;
 
@@ -8,19 +8,12 @@ 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, ""))
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><video src=\"movie.mp4\"></video><audio src=\"sound.mp3\"></audio></body></html>";
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
             {
-                // 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)
@@ -33,9 +26,8 @@ static void Main()
                                 {
                                     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}");
+                                    string srcValue = element.GetAttribute("src");
+                                    System.Console.WriteLine($"Tag: {tagName}, Attribute: {srcValue}, Message: {techResult.Error.ErrorMessage}");
                                 }
                             }
                         }
@@ -43,13 +35,13 @@ static void Main()
                 }
                 else
                 {
-                    Console.WriteLine("Document passed accessibility validation.");
+                    System.Console.WriteLine("Document passed accessibility validation.");
                 }
             }
         }
         catch (Exception ex)
         {
-            Console.WriteLine($"Error: {ex.Message}");
+            System.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/execute-validator-validate-with-file-path-to-run-accessibility-checks-on-page.cs
similarity index 58%
rename from web-accessibility/create_static_accessibilityvalidator_instance_and_reuse_to_validate_multiple_html_files_efficiently.cs
rename to web-accessibility/execute-validator-validate-with-file-path-to-run-accessibility-checks-on-page.cs
index c20f67f..268c0e2 100644
--- a/web-accessibility/create_static_accessibilityvalidator_instance_and_reuse_to_validate_multiple_html_files_efficiently.cs
+++ b/web-accessibility/execute-validator-validate-with-file-path-to-run-accessibility-checks-on-page.cs
@@ -1,4 +1,4 @@
-// Create a static AccessibilityValidator instance and reuse it to validate multiple HTML files efficiently.
+// Execute validator.Validate with the file path to run accessibility checks on the page.
 
 using System;
 
@@ -8,23 +8,20 @@ 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);
+            if (!System.IO.File.Exists(htmlPath))
+            {
+                System.IO.File.WriteAllText(htmlPath, "<!DOCTYPE html><html><head><title>Sample</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(htmlPath))
             {
                 var validationResult = validator.Validate(document);
-
                 if (validationResult.Success)
                 {
-                    Console.WriteLine("Document passed accessibility validation.");
+                    System.Console.WriteLine("Accessibility validation succeeded.");
                 }
                 else
                 {
@@ -34,17 +31,16 @@ static void Main()
                         {
                             foreach (var techResult in ruleResult.Errors)
                             {
-                                var error = techResult.Error;
-                                Console.WriteLine(error.ErrorMessage);
+                                System.Console.WriteLine(techResult.Error.ErrorMessage);
                             }
                         }
                     }
                 }
             }
         }
-        catch (Exception ex)
+        catch (System.Exception ex)
         {
-            Console.WriteLine($"Error: {ex.Message}");
+            System.Console.WriteLine("Error: " + ex.Message);
         }
     }
 }
\ 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
deleted file mode 100644
index 666ae44..0000000
--- a/web-accessibility/execute_validate_method_assess_multimedia_accessibility_loaded_html_document.cs
+++ /dev/null
@@ -1,72 +0,0 @@
-// 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
deleted file mode 100644
index 25d4a31..0000000
--- a/web-accessibility/execute_validator_validate_with_file_path_to_run_accessibility_checks_on_page.cs
+++ /dev/null
@@ -1,74 +0,0 @@
-// 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-save-to-string-developer-review.cs b/web-accessibility/export-validation-results-formatted-string-save-to-string-developer-review.cs
new file mode 100644
index 0000000..808ec05
--- /dev/null
+++ b/web-accessibility/export-validation-results-formatted-string-save-to-string-developer-review.cs
@@ -0,0 +1,24 @@
+// Export validation results as a formatted string using SaveToString for developer review.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string html = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1></body></html>";
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(html, "about:blank");
+            Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+            Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+            string result = validationResult.SaveToString();
+            System.Console.WriteLine("Validation Results:");
+            System.Console.WriteLine(result);
+        }
+        catch (Exception ex)
+        {
+            System.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
deleted file mode 100644
index c78b848..0000000
--- a/web-accessibility/export_validation_results_formatted_string_developer_review.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-// 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..a009f2e
--- /dev/null
+++ b/web-accessibility/fail-build-if-critical-accessibility-errors-detected-enforce-quality-gates.cs
@@ -0,0 +1,47 @@
+// Fail the build if any critical accessibility errors are detected to enforce quality gates.
+
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</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, "about:blank"))
+            {
+                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)
+                            {
+                                System.Console.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+
+                    // Fail the build due to critical accessibility errors
+                    System.Environment.Exit(1);
+                }
+                else
+                {
+                    System.Console.WriteLine("Accessibility validation passed.");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Console.Error.WriteLine("Error: " + ex.Message);
+            System.Environment.Exit(1);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/fail-ci-build-when-validationresult-contains-error-level-findings-to-enforce-accessibility-standards.cs b/web-accessibility/fail-ci-build-when-validationresult-contains-error-level-findings-to-enforce-accessibility-standards.cs
new file mode 100644
index 0000000..db22439
--- /dev/null
+++ b/web-accessibility/fail-ci-build-when-validationresult-contains-error-level-findings-to-enforce-accessibility-standards.cs
@@ -0,0 +1,52 @@
+// Fail a CI build when ValidationResult contains any error‑level findings to enforce accessibility standards.
+
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Example</h1></body></html>";
+
+            // 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 HTML document from inline content
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (validationResult.Success)
+                {
+                    System.Console.WriteLine("Accessibility validation passed. No errors found.");
+                }
+                else
+                {
+                    // Output error messages
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                System.Console.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+
+                    // Fail the build by setting a non-zero exit code
+                    System.Environment.ExitCode = 1;
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Console.WriteLine("An unexpected error occurred: " + ex.Message);
+            System.Environment.ExitCode = 1;
+        }
+    }
+}
\ 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
deleted file mode 100644
index a029980..0000000
--- a/web-accessibility/fail_build_if_critical_accessibility_errors_detected_enforce_quality_gates.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-// 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
deleted file mode 100644
index 048ef6d..0000000
--- a/web-accessibility/fail_ci_build_validationresult_contains_error_level_findings_enforce_accessibility_standards.cs
+++ /dev/null
@@ -1,68 +0,0 @@
-// 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/use_accessibilityrules_getall_fetch_all_wcag_rule_codes_and_descriptions_for_ui_display.cs b/web-accessibility/fetch-all-wcag-rule-codes-and-descriptions-for-ui-display-using-accessibilityrules-getall.cs
similarity index 59%
rename from web-accessibility/use_accessibilityrules_getall_fetch_all_wcag_rule_codes_and_descriptions_for_ui_display.cs
rename to web-accessibility/fetch-all-wcag-rule-codes-and-descriptions-for-ui-display-using-accessibilityrules-getall.cs
index 2ed4503..24bd8cf 100644
--- a/web-accessibility/use_accessibilityrules_getall_fetch_all_wcag_rule_codes_and_descriptions_for_ui_display.cs
+++ b/web-accessibility/fetch-all-wcag-rule-codes-and-descriptions-for-ui-display-using-accessibilityrules-getall.cs
@@ -1,7 +1,6 @@
 // Use AccessibilityRules.GetAll to fetch all WCAG rule codes and descriptions for UI display.
 
 using System;
-using System.IO;
 
 class Program
 {
@@ -9,29 +8,22 @@ 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>");
+            // Initialize WebAccessibility object
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
 
-            // 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");
+            // Retrieve a specific principle (replace with a valid principle code if needed)
+            Aspose.Html.Accessibility.Principle principle = webAccessibility.Rules.GetPrinciple("1.1");
             if (principle != null)
             {
-                // Retrieve a guideline (example code "1.1.1")
-                var guideline = principle.GetGuideline("1.1.1");
+                // Retrieve a specific guideline (replace with a valid guideline code if needed)
+                Aspose.Html.Accessibility.Guideline 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");
+                    // Retrieve a specific criterion (replace with a valid criterion code if needed)
+                    Aspose.Html.Accessibility.Criterion criterion = guideline.GetCriterion("1.1.1.1");
                     if (criterion != null)
                     {
+                        // Output criterion information
                         Console.WriteLine("{0}:{1} - {2}", criterion.Code, criterion.Description, criterion.Level);
 
                         // List sufficient techniques for the criterion
diff --git a/web-accessibility/fetch-html-content-list-urls-validate-each-page-save-results-xml-files.cs b/web-accessibility/fetch-html-content-list-urls-validate-each-page-save-results-xml-files.cs
new file mode 100644
index 0000000..b7b6827
--- /dev/null
+++ b/web-accessibility/fetch-html-content-list-urls-validate-each-page-save-results-xml-files.cs
@@ -0,0 +1,41 @@
+// Fetch HTML content from a list of URLs, validate each page, and save results as XML files.
+
+namespace AsposeHtmlValidationExample
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            try
+            {
+                System.Collections.Generic.List<string> urls = new System.Collections.Generic.List<string>
+                {
+                    "https://example.com",
+                    "https://example.org"
+                };
+
+                string outputDirectory = "ValidationResults";
+                System.IO.Directory.CreateDirectory(outputDirectory);
+
+                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(outputDirectory, $"validation_result_{index}.xml");
+                        System.IO.File.WriteAllText(outputPath, validationResult.ToString());
+                    }
+                    index++;
+                }
+            }
+            catch (System.Exception ex)
+            {
+                System.Console.WriteLine("An error occurred: " + 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
deleted file mode 100644
index 81ca552..0000000
--- a/web-accessibility/fetch_html_content_url_list_validate_pages_save_results_xml_files.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-// 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/embed_validation_results_string_into_email_body_notify_stakeholders_accessibility_status.cs b/web-accessibility/filter-errors-by-target-types-to-separate-html-element-issues-from-css-related-problems.cs
similarity index 57%
rename from web-accessibility/embed_validation_results_string_into_email_body_notify_stakeholders_accessibility_status.cs
rename to web-accessibility/filter-errors-by-target-types-to-separate-html-element-issues-from-css-related-problems.cs
index 9b0526a..ac586c9 100644
--- a/web-accessibility/embed_validation_results_string_into_email_body_notify_stakeholders_accessibility_status.cs
+++ b/web-accessibility/filter-errors-by-target-types-to-separate-html-element-issues-from-css-related-problems.cs
@@ -1,32 +1,22 @@
-// Embed validation results string into an email body to notify stakeholders of accessibility status.
+// Filter errors by Target.TargetTypes to separate HTML element issues from CSS related problems.
 
 using System;
-using System.IO;
 
 class Program
 {
-    static void Main()
+    static void Main(string[] args)
     {
         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);
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src=\"image.png\" alt=\"\" /></body></html>";
 
-            // Create WebAccessibility instance and validator
+            // 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))
+            // Load HTML document (using two-argument constructor to avoid file path issues)
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
             {
                 // Perform validation
                 Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
@@ -39,13 +29,19 @@ static void Main()
                         {
                             foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
                             {
+                                // Separate HTML element issues from CSS related problems
                                 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}");
+                                    // Example: retrieve a common attribute; adjust as needed
+                                    string attributeValue = element.GetAttribute("alt");
+                                    Console.WriteLine($"HTML Element Issue - Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                                else
+                                {
+                                    // Treat all non-HTMLElement targets as CSS related issues
+                                    Console.WriteLine($"CSS Issue - Message: {techResult.Error.ErrorMessage}");
                                 }
                             }
                         }
@@ -53,15 +49,9 @@ static void Main()
                 }
                 else
                 {
-                    Console.WriteLine("Document passed accessibility validation successfully.");
+                    Console.WriteLine("Document passed all accessibility checks.");
                 }
             }
-
-            // Clean up temporary file
-            if (File.Exists(tempFilePath))
-            {
-                File.Delete(tempFilePath);
-            }
         }
         catch (Exception ex)
         {
diff --git a/web-accessibility/filter-rule-set-error-level-criteria-before-validation-critical-problems.cs b/web-accessibility/filter-rule-set-error-level-criteria-before-validation-critical-problems.cs
new file mode 100644
index 0000000..61449ba
--- /dev/null
+++ b/web-accessibility/filter-rule-set-error-level-criteria-before-validation-critical-problems.cs
@@ -0,0 +1,45 @@
+// 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 with an accessibility issue (image without alt text)
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src='missing.jpg'></body></html>";
+
+            // Load HTML document from inline content
+            var document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank");
+
+            // 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);
+
+            // Perform validation
+            var validationResult = validator.Validate(document);
+
+            // Process only error‑level rule results
+            if (!validationResult.Success)
+            {
+                foreach (var detail in validationResult.Details)
+                {
+                    if (!detail.Success)
+                    {
+                        Console.WriteLine($"{detail.Rule.Code}: {detail.Rule.Description}");
+                    }
+                }
+            }
+            else
+            {
+                Console.WriteLine("No accessibility errors found.");
+            }
+        }
+        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-targeted-video-improvements.cs b/web-accessibility/filter-validation-results-audio-description-warnings-targeted-video-improvements.cs
new file mode 100644
index 0000000..a8dc75b
--- /dev/null
+++ b/web-accessibility/filter-validation-results-audio-description-warnings-targeted-video-improvements.cs
@@ -0,0 +1,62 @@
+// Filter validation results to display only audio‑description warnings for targeted video improvements.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content with a video element (no audio description)
+            string htmlContent = "<html><body><video src='sample.mp4'></video></body></html>";
+
+            // Create a WebAccessibility instance
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+            // Create a validator that runs all checks
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load the HTML document from the inline content
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                // If validation failed, process the 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)
+                            {
+                                // Filter for audio‑description related warnings
+                                if (techResult.Error.ErrorMessage != null &&
+                                    techResult.Error.ErrorMessage.IndexOf("audio", StringComparison.OrdinalIgnoreCase) >= 0)
+                                {
+                                    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");
+                                        System.Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    System.Console.WriteLine("No accessibility issues detected.");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            System.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-efforts.cs b/web-accessibility/filter-validation-results-display-only-caption-related-warnings-focused-remediation-efforts.cs
new file mode 100644
index 0000000..c418408
--- /dev/null
+++ b/web-accessibility/filter-validation-results-display-only-caption-related-warnings-focused-remediation-efforts.cs
@@ -0,0 +1,55 @@
+// Filter validation results to display only caption‑related warnings for focused remediation efforts.
+
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            // Sample HTML content with a table missing a caption (to generate caption-related warnings)
+            string htmlContent = "<html><body><table><tr><td>Data</td></tr></table></body></html>";
+
+            // Load HTML document from string (using two-argument constructor)
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank");
+
+            // Create WebAccessibility instance and validator with 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);
+
+            // Filter and display only caption-related warnings
+            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 errorMessage = techResult.Error.ErrorMessage;
+
+                                if (tagName.Equals("CAPTION", StringComparison.OrdinalIgnoreCase) ||
+                                    errorMessage.IndexOf("caption", StringComparison.OrdinalIgnoreCase) >= 0)
+                                {
+                                    Console.WriteLine($"Tag: {tagName}, Message: {errorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/filter-warnings-specific-ruleid-values-focus-particular-accessibility-techniques.cs b/web-accessibility/filter-warnings-specific-ruleid-values-focus-particular-accessibility-techniques.cs
new file mode 100644
index 0000000..ddf7908
--- /dev/null
+++ b/web-accessibility/filter-warnings-specific-ruleid-values-focus-particular-accessibility-techniques.cs
@@ -0,0 +1,56 @@
+// Filter warnings by specific RuleId values to focus on particular accessibility techniques.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Define HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><img src='missing.jpg' alt=''></body></html>";
+            // Create WebAccessibility instance
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            // Create validator with all rules
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            // Load HTML document from inline content
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                // Validate the document
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                if (!validationResult.Success)
+                {
+                    // Define rule IDs to filter
+                    string[] filterRuleIds = new string[] { "R1", "R2" }; // replace with actual rule IDs of interest
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success && ruleResult.Rule != null)
+                        {
+                            // Filter by specific RuleId (using Rule.Code as identifier)
+                            if (System.Array.IndexOf(filterRuleIds, ruleResult.Rule.Code) >= 0)
+                            {
+                                foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                                {
+                                    if (techResult.Error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                    {
+                                        System.Console.WriteLine(techResult.Error.ErrorMessage);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    System.Console.WriteLine("No accessibility warnings detected.");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            System.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
deleted file mode 100644
index d194e38..0000000
--- a/web-accessibility/filter_errors_by_target_type_separate_html_element_issues_from_css_problems.cs
+++ /dev/null
@@ -1,78 +0,0 @@
-// 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
deleted file mode 100644
index a38b8ef..0000000
--- a/web-accessibility/filter_rule_set_include_only_error_level_criteria_before_validation_focus_critical_problems.cs
+++ /dev/null
@@ -1,70 +0,0 @@
-// 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
deleted file mode 100644
index 82bb220..0000000
--- a/web-accessibility/filter_validation_results_audio_description_warnings_video_improvements.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-// 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
deleted file mode 100644
index 452c26c..0000000
--- a/web-accessibility/filter_validation_results_display_only_caption_related_warnings_focused_remediation.cs
+++ /dev/null
@@ -1,113 +0,0 @@
-// 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
deleted file mode 100644
index 7ea3b51..0000000
--- a/web-accessibility/filter_warnings_by_specific_ruleid_values_to_focus_particular_accessibility_techniques.cs
+++ /dev/null
@@ -1,133 +0,0 @@
-// 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-format-save-specified-output-directory.cs b/web-accessibility/generate-detailed-validation-report-json-format-save-specified-output-directory.cs
new file mode 100644
index 0000000..9b80a1e
--- /dev/null
+++ b/web-accessibility/generate-detailed-validation-report-json-format-save-specified-output-directory.cs
@@ -0,0 +1,42 @@
+// Generate a detailed validation report in JSON format and save it to a specified output directory.
+
+using System;
+using System.IO;
+using System.Security;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            string outputDirectory = "Output";
+            Directory.CreateDirectory(outputDirectory);
+
+            string inputHtmlPath = "sample.html";
+            if (!File.Exists(inputHtmlPath))
+            {
+                string sampleHtml = "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello World</h1></body></html>";
+                File.WriteAllText(inputHtmlPath, sampleHtml);
+            }
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputHtmlPath))
+            {
+                Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                string xmlReport = validationResult.SaveToString();
+                string escapedXml = SecurityElement.Escape(xmlReport);
+                string jsonReport = $"{{\"validationReport\": \"{escapedXml}\"}}";
+
+                string jsonPath = Path.Combine(outputDirectory, "validationReport.json");
+                File.WriteAllText(jsonPath, jsonReport);
+            }
+
+            Console.WriteLine("Validation report saved successfully.");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/generate-markdown-report-validationresult-post-pull-request-comments.cs b/web-accessibility/generate-markdown-report-validationresult-post-pull-request-comments.cs
new file mode 100644
index 0000000..c74481e
--- /dev/null
+++ b/web-accessibility/generate-markdown-report-validationresult-post-pull-request-comments.cs
@@ -0,0 +1,55 @@
+// Generate a markdown report from ValidationResult to post directly in pull‑request comments.
+
+using System;
+using System.IO;
+using System.Text;
+using Aspose.Html;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>";
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                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);
+
+                StringBuilder sb = new StringBuilder();
+                sb.AppendLine("# Accessibility Validation Report");
+                sb.AppendLine();
+                sb.AppendLine("| Rule Code | Description | Success |");
+                sb.AppendLine("|-----------|-------------|---------|");
+
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                    {
+                        string code = detail.Rule != null ? detail.Rule.Code : "";
+                        string description = detail.Rule != null ? detail.Rule.Description : "";
+                        string success = detail.Success ? "✅" : "❌";
+                        sb.AppendLine($"| {code} | {description} | {success} |");
+                    }
+                }
+                else
+                {
+                    sb.AppendLine("| - | All rules passed | ✅ |");
+                }
+
+                string markdown = sb.ToString();
+                string outputPath = "validation_report.md";
+                System.IO.File.WriteAllText(outputPath, markdown);
+                System.Console.WriteLine("Markdown report saved to " + outputPath);
+            }
+        }
+        catch (System.Exception ex)
+        {
+            System.Console.Error.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/generate-plain-text-summary-validation-findings-quick-review-developers.cs
similarity index 57%
rename from web-accessibility/call_validationresult_savetostring_obtain_formatted_string_errors_warnings.cs
rename to web-accessibility/generate-plain-text-summary-validation-findings-quick-review-developers.cs
index 66548c1..d34b13a 100644
--- a/web-accessibility/call_validationresult_savetostring_obtain_formatted_string_errors_warnings.cs
+++ b/web-accessibility/generate-plain-text-summary-validation-findings-quick-review-developers.cs
@@ -1,19 +1,15 @@
-// Call ValidationResult.SaveToString to obtain a formatted string of errors and warnings.
+// Generate a plain‑text summary of validation findings for quick review by developers.
 
 using System;
-using System.IO;
 
 class Program
 {
-    static void Main()
+    static void Main(string[] args)
     {
         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))
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src='missing.jpg' alt=''></body></html>";
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
             {
                 Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
                 Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
@@ -21,19 +17,19 @@ static void Main()
 
                 if (!validationResult.Success)
                 {
-                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
                     {
-                        if (!detail.Success)
+                        if (!ruleResult.Success)
                         {
-                            Console.WriteLine(detail.Rule.Code + ": " + detail.Rule.Description);
-                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in detail.Errors)
+                            System.Console.WriteLine(ruleResult.Rule.Code + " - " + ruleResult.Rule.Description);
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
                             {
                                 Aspose.Html.Accessibility.IError error = techResult.Error;
-                                Console.WriteLine("Error: " + error.ErrorMessage);
+                                System.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);
+                                    System.Console.WriteLine("Element: " + element.OuterHTML);
                                 }
                             }
                         }
@@ -41,18 +37,13 @@ static void Main()
                 }
                 else
                 {
-                    Console.WriteLine("Document passed accessibility validation.");
+                    System.Console.WriteLine("Validation succeeded. No issues found.");
                 }
             }
-
-            if (File.Exists(tempFile))
-            {
-                File.Delete(tempFile);
-            }
         }
-        catch (Exception ex)
+        catch (System.Exception ex)
         {
-            Console.WriteLine("An error occurred: " + ex.Message);
+            System.Console.WriteLine("Error: " + ex.Message);
         }
     }
 }
\ No newline at end of file
diff --git a/web-accessibility/generate-summary-report-aggregates-total-errors-across-all-processed-html-documents-batch.cs b/web-accessibility/generate-summary-report-aggregates-total-errors-across-all-processed-html-documents-batch.cs
new file mode 100644
index 0000000..65d9a2d
--- /dev/null
+++ b/web-accessibility/generate-summary-report-aggregates-total-errors-across-all-processed-html-documents-batch.cs
@@ -0,0 +1,70 @@
+// Generate a summary report that aggregates total errors across all processed HTML documents in a batch.
+
+using System;
+using System.IO;
+using Aspose.Html.Net;
+
+public class LogHandler : Aspose.Html.Net.MessageHandler
+{
+    public override void Invoke(Aspose.Html.Net.INetworkOperationContext context)
+    {
+        Next(context);
+        if ((int)context.Response.StatusCode >= 400)
+        {
+            Program.ErrorCount++;
+        }
+        Console.WriteLine(context.Request.RequestUri + " | " + context.Response.StatusCode);
+    }
+}
+
+public class Program
+{
+    public static int ErrorCount = 0;
+
+    public static void Main()
+    {
+        try
+        {
+            string inputDir = "InputHtml";
+            if (!Directory.Exists(inputDir))
+                Directory.CreateDirectory(inputDir);
+
+            if (Directory.GetFiles(inputDir, "*.html").Length == 0)
+            {
+                for (int i = 1; i <= 2; i++)
+                {
+                    string samplePath = Path.Combine(inputDir, $"sample{i}.html");
+                    File.WriteAllText(samplePath, $"<html><body><h1>Sample {i}</h1></body></html>");
+                }
+            }
+
+            foreach (string htmlPath in Directory.GetFiles(inputDir, "*.html"))
+            {
+                try
+                {
+                    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);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    ErrorCount++;
+                    Console.WriteLine($"Error processing '{htmlPath}': {ex.Message}");
+                }
+            }
+
+            Console.WriteLine($"Total errors across all documents: {ErrorCount}");
+        }
+        catch (Exception e)
+        {
+            Console.WriteLine($"Fatal error: {e.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
deleted file mode 100644
index 3769a0d..0000000
--- a/web-accessibility/generate_markdown_report_from_validationresult_to_post_in_pull_request_comments.cs
+++ /dev/null
@@ -1,107 +0,0 @@
-// 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/identify-video-elements-lacking-audio-description-tracks-filtering-validation-messages-description-warnings.cs b/web-accessibility/identify-video-elements-lacking-audio-description-tracks-filtering-validation-messages-description-warnings.cs
new file mode 100644
index 0000000..a520cfd
--- /dev/null
+++ b/web-accessibility/identify-video-elements-lacking-audio-description-tracks-filtering-validation-messages-description-warnings.cs
@@ -0,0 +1,59 @@
+// Identify video elements lacking audio description tracks by filtering validation messages for description warnings.
+
+using System;
+
+namespace Example
+{
+    class Program
+    {
+        static void Main()
+        {
+            try
+            {
+                string htmlContent = "<!DOCTYPE html><html><body>" +
+                    "<video src='video1.mp4'></video>" +
+                    "<video src='video2.mp4'><track kind='descriptions' src='desc.vtt'></track></video>" +
+                    "</body></html>";
+
+                using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+                {
+                    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;
+                                        if (techResult.Error.ErrorMessage != null && techResult.Error.ErrorMessage.IndexOf("description", StringComparison.OrdinalIgnoreCase) >= 0)
+                                        {
+                                            string src = element.GetAttribute("src");
+                                            Console.WriteLine($"Video element missing audio description. Tag: {tagName}, src: {src}, Message: {techResult.Error.ErrorMessage}");
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    else
+                    {
+                        Console.WriteLine("No accessibility issues found.");
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"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
deleted file mode 100644
index 469ad09..0000000
--- a/web-accessibility/identify_video_elements_lacking_audio_description_tracks_by_filtering_validation_messages_for_description_warnings.cs
+++ /dev/null
@@ -1,68 +0,0 @@
-// 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-when-validating-remote-html-content-may-experience-transient-network-failures.cs b/web-accessibility/implement-retry-mechanism-when-validating-remote-html-content-may-experience-transient-network-failures.cs
new file mode 100644
index 0000000..3539cf0
--- /dev/null
+++ b/web-accessibility/implement-retry-mechanism-when-validating-remote-html-content-may-experience-transient-network-failures.cs
@@ -0,0 +1,53 @@
+// Implement a retry mechanism when validating remote HTML content that may experience transient network failures.
+
+using System;
+using System.Net;
+
+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;
+        }
+    }
+}
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string url = "https://example.com";
+
+            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));
+
+            Aspose.Html.Net.RequestMessage request = new Aspose.Html.Net.RequestMessage(url);
+            request.Timeout = TimeSpan.FromSeconds(10);
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(request, configuration))
+            {
+                string html = ((Aspose.Html.HTMLElement)document.DocumentElement).OuterHTML;
+                Console.WriteLine(html);
+            }
+        }
+        catch (Exception ex)
+        {
+            if (ex.Message.Contains("network"))
+            {
+                Console.WriteLine("Network error occurred while loading the HTML content.");
+            }
+            else
+            {
+                Console.WriteLine(ex.Message);
+            }
+        }
+    }
+}
\ 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..e22185f
--- /dev/null
+++ b/web-accessibility/incorporate-color-contrast-verification-results-into-overall-validation-summary-for-comprehensive-reporting.cs
@@ -0,0 +1,64 @@
+// Incorporate color contrast verification results into the overall validation summary for comprehensive reporting.
+
+using System;
+
+namespace AsposeHtmlAccessibilityExample
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            try
+            {
+                string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><p style='color:#777;'>Sample text</p></body></html>";
+                using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+                {
+                    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);
+
+                    // Overall validation summary
+                    System.Console.WriteLine("Overall Validation Success: " + validationResult.Success);
+
+                    // Detailed rule results
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        System.Console.WriteLine("Rule: " + ruleResult.Rule.Code + " - " + ruleResult.Rule.Description + " | Success: " + ruleResult.Success);
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                Aspose.Html.Accessibility.IError error = techResult.Error;
+                                System.Console.WriteLine("  Error: " + error.ErrorMessage);
+                                if (error.Target.TargetType == Aspose.Html.Accessibility.TargetTypes.HTMLElement)
+                                {
+                                    Aspose.Html.HTMLElement element = (Aspose.Html.HTMLElement)error.Target.Item;
+                                    System.Console.WriteLine("    Element: " + element.OuterHTML);
+                                }
+                            }
+                        }
+                    }
+
+                    // Specific color contrast verification summary
+                    bool colorContrastFound = false;
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (ruleResult.Rule.Code != null && ruleResult.Rule.Code.IndexOf("ColorContrast", System.StringComparison.OrdinalIgnoreCase) >= 0)
+                        {
+                            colorContrastFound = true;
+                            System.Console.WriteLine("Color Contrast Verification - Success: " + ruleResult.Success);
+                        }
+                    }
+                    if (!colorContrastFound)
+                    {
+                        System.Console.WriteLine("No specific Color Contrast rule found in validation results.");
+                    }
+                }
+            }
+            catch (System.Exception ex)
+            {
+                System.Console.WriteLine("Error: " + ex.Message);
+            }
+        }
+    }
+}
\ 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
deleted file mode 100644
index c98de1e..0000000
--- a/web-accessibility/incorporate_color_contrast_verification_results_into_overall_validation_summary_for_comprehensive_reporting.cs
+++ /dev/null
@@ -1,74 +0,0 @@
-// 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-html-document-from-file-path-and-validate-with-default-validator.cs b/web-accessibility/initialize-html-document-from-file-path-and-validate-with-default-validator.cs
new file mode 100644
index 0000000..069157d
--- /dev/null
+++ b/web-accessibility/initialize-html-document-from-file-path-and-validate-with-default-validator.cs
@@ -0,0 +1,47 @@
+// Initialize an HTMLDocument from a file path and validate it using the default validator.
+
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            // Define input HTML file path
+            string inputPath = "sample.html";
+
+            // Create a minimal HTML file if it does not exist
+            if (!System.IO.File.Exists(inputPath))
+            {
+                string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><p>Hello World</p></body></html>";
+                System.IO.File.WriteAllText(inputPath, htmlContent);
+            }
+
+            // Load the HTML document from the file path
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath))
+            {
+                // Create the default accessibility validator
+                Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+
+                // Validate the document
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                // Save validation result to a string in XML format
+                using (System.IO.StringWriter sw = new System.IO.StringWriter())
+                {
+                    validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                    string xmlResult = sw.ToString();
+
+                    // Output the validation result
+                    System.Console.WriteLine("Validation Result (XML):");
+                    System.Console.WriteLine(xmlResult);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            System.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
deleted file mode 100644
index 07be699..0000000
--- a/web-accessibility/initialize_htmldocument_from_file_path_and_validate_using_default_validator.cs
+++ /dev/null
@@ -1,54 +0,0 @@
-// 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..9fe1a5e
--- /dev/null
+++ b/web-accessibility/inject-accessibilityvalidator-dependency-injection-enable-flexible-configuration-aspnet-core-applications.cs
@@ -0,0 +1,59 @@
+// Inject AccessibilityValidator via dependency injection to enable flexible configuration in ASP.NET Core applications.
+
+using System;
+
+class AccessibilityService
+{
+    private readonly Aspose.Html.Accessibility.AccessibilityValidator _validator;
+
+    public AccessibilityService(Aspose.Html.Accessibility.AccessibilityValidator validator)
+    {
+        _validator = validator;
+    }
+
+    public void Validate(string htmlContent)
+    {
+        using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+        {
+            Aspose.Html.Accessibility.Results.ValidationResult validationResult = _validator.Validate(document);
+            if (validationResult.Success)
+            {
+                System.Console.WriteLine("Accessibility validation succeeded.");
+            }
+            else
+            {
+                foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                {
+                    if (!ruleResult.Success)
+                    {
+                        foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                        {
+                            System.Console.WriteLine(techResult.Error.ErrorMessage);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string html = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Sample</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);
+
+            AccessibilityService service = new AccessibilityService(validator);
+            service.Validate(html);
+        }
+        catch (Exception ex)
+        {
+            System.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
deleted file mode 100644
index e10cdb0..0000000
--- a/web-accessibility/inject_accessibilityvalidator_dependency_injection_enable_flexible_configuration_aspnet_core_applications.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-// 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-accessibility-validator-using-createvalidator-before-loading-html-document.cs b/web-accessibility/instantiate-accessibility-validator-using-createvalidator-before-loading-html-document.cs
new file mode 100644
index 0000000..a20359a
--- /dev/null
+++ b/web-accessibility/instantiate-accessibility-validator-using-createvalidator-before-loading-html-document.cs
@@ -0,0 +1,44 @@
+// Instantiate an AccessibilityValidator using CreateValidator before loading any HTML document.
+
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Accessibility Test</h1></body></html>";
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                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/instantiate_accessibilityvalidator_using_createvalidator_before_loading_any_html_document.cs b/web-accessibility/instantiate_accessibilityvalidator_using_createvalidator_before_loading_any_html_document.cs
deleted file mode 100644
index ce2a7d0..0000000
--- a/web-accessibility/instantiate_accessibilityvalidator_using_createvalidator_before_loading_any_html_document.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-// 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/verify_each_track_element_includes_valid_srclang_attribute_for_accessibility_standards.cs b/web-accessibility/integrate-accessibility-validation-aspose-html-workflows-multimedia-processing-pipeline.cs
similarity index 60%
rename from web-accessibility/verify_each_track_element_includes_valid_srclang_attribute_for_accessibility_standards.cs
rename to web-accessibility/integrate-accessibility-validation-aspose-html-workflows-multimedia-processing-pipeline.cs
index 517f56a..a485dd4 100644
--- a/web-accessibility/verify_each_track_element_includes_valid_srclang_attribute_for_accessibility_standards.cs
+++ b/web-accessibility/integrate-accessibility-validation-aspose-html-workflows-multimedia-processing-pipeline.cs
@@ -1,30 +1,31 @@
-// Verify that each <track> element includes a valid srclang attribute to meet accessibility standards.
+// Integrate accessibility validation into Aspose.HTML workflows as part of the multimedia processing pipeline.
 
 using System;
-using System.IO;
 
 class Program
 {
-    static void Main()
+    static void Main(string[] args)
     {
         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>");
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src='image.jpg'></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))
+            // Load HTML document from string (using two-argument constructor)
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
             {
                 // Perform validation
                 Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
 
-                // If validation failed, output details
-                if (!validationResult.Success)
+                if (validationResult.Success)
+                {
+                    System.Console.WriteLine("Document passed accessibility validation.");
+                }
+                else
                 {
                     foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
                     {
@@ -36,28 +37,22 @@ static void Main()
                                 {
                                     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}");
+                                    string attributeValue = element.GetAttribute("src");
+                                    System.Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                                else
+                                {
+                                    System.Console.WriteLine(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}");
+            System.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..8421f5e
--- /dev/null
+++ b/web-accessibility/integrate-validation-step-into-ci-cd-pipeline-using-command-line-invocation-validator.cs
@@ -0,0 +1,49 @@
+// Integrate the validation step into a CI/CD pipeline using a command‑line invocation of the validator.
+
+namespace Example
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            try
+            {
+                string inputPath;
+                if (args.Length > 0 && !string.IsNullOrWhiteSpace(args[0]))
+                {
+                    inputPath = args[0];
+                }
+                else
+                {
+                    string tempDir = System.IO.Path.GetTempPath();
+                    inputPath = System.IO.Path.Combine(tempDir, "sample.html");
+                    if (!System.IO.File.Exists(inputPath))
+                    {
+                        string sampleHtml = "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello World</h1></body></html>";
+                        System.IO.File.WriteAllText(inputPath, sampleHtml);
+                    }
+                }
+
+                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);
+
+                    System.Console.WriteLine("Validation Success: " + validationResult.Success);
+                    if (!validationResult.Success)
+                    {
+                        foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                        {
+                            System.Console.WriteLine($"Rule: {detail.Rule.Code} - {detail.Rule.Description} - Success: {detail.Success}");
+                        }
+                    }
+                }
+            }
+            catch (System.Exception ex)
+            {
+                System.Console.Error.WriteLine("Error: " + ex.Message);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/integrate-validation-step-into-github-actions-workflow-automatically-test-pull-requests.cs b/web-accessibility/integrate-validation-step-into-github-actions-workflow-automatically-test-pull-requests.cs
new file mode 100644
index 0000000..0d3b797
--- /dev/null
+++ b/web-accessibility/integrate-validation-step-into-github-actions-workflow-automatically-test-pull-requests.cs
@@ -0,0 +1,47 @@
+// Integrate the validation step into a GitHub Actions workflow to automatically test pull requests.
+
+namespace Example
+{
+    class Program
+    {
+        static int Main(string[] args)
+        {
+            try
+            {
+                // 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);
+
+                // Sample HTML content
+                string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1></body></html>";
+
+                // Load HTML document using two-argument constructor (content, baseUri)
+                Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank");
+
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                if (!validationResult.Success)
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                    {
+                        System.Console.WriteLine($"Rule: {detail.Rule.Code} - {detail.Rule.Description} - Success: {detail.Success}");
+                    }
+                    System.Environment.ExitCode = 1;
+                }
+                else
+                {
+                    System.Console.WriteLine("Validation succeeded.");
+                    System.Environment.ExitCode = 0;
+                }
+            }
+            catch (System.Exception ex)
+            {
+                System.Console.Error.WriteLine($"Error: {ex.Message}");
+                System.Environment.ExitCode = 1;
+            }
+
+            return System.Environment.ExitCode;
+        }
+    }
+}
\ 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
deleted file mode 100644
index 21722f9..0000000
--- a/web-accessibility/integrate_validation_step_into_github_actions_workflow_to_automatically_test_pull_requests.cs
+++ /dev/null
@@ -1,111 +0,0 @@
-// 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..1c07bb6
--- /dev/null
+++ b/web-accessibility/iterate-accessibility-rules-advisory-techniques-list-improvement-suggestions-each-identified-issue.cs
@@ -0,0 +1,52 @@
+// Iterate AccessibilityRules.AdvisoryTechniques to list improvement suggestions for each identified issue.
+
+using System;
+
+namespace Example
+{
+    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);
+
+                string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src='image.jpg'></body></html>";
+                using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+                {
+                    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("No accessibility issues found.");
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error: {ex.Message}");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/iterate-through-validationresult-details-log-rule-identifier-pass-fail-status.cs b/web-accessibility/iterate-through-validationresult-details-log-rule-identifier-pass-fail-status.cs
new file mode 100644
index 0000000..b1bc234
--- /dev/null
+++ b/web-accessibility/iterate-through-validationresult-details-log-rule-identifier-pass-fail-status.cs
@@ -0,0 +1,42 @@
+// Iterate through ValidationResult.Details to log each rule identifier and its pass or fail status.
+
+using System;
+
+namespace Example
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            try
+            {
+                // Sample HTML content
+                string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello World</h1></body></html>";
+
+                // Load HTML document from inline content
+                Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank");
+
+                // 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);
+
+                // Log overall validation status
+                System.Console.WriteLine($"Validation Success: {validationResult.Success}");
+
+                // Iterate through each rule result
+                foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                {
+                    string ruleCode = detail.Rule != null ? detail.Rule.Code : "N/A";
+                    System.Console.WriteLine($"Rule: {ruleCode}, Passed: {detail.Success}");
+                }
+            }
+            catch (Exception ex)
+            {
+                System.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
deleted file mode 100644
index 75a75d0..0000000
--- a/web-accessibility/iterate_accessibility_rules_advisory_techniques_list_improvement_suggestions_each_identified_issue.cs
+++ /dev/null
@@ -1,134 +0,0 @@
-// 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
deleted file mode 100644
index 1a4f953..0000000
--- a/web-accessibility/iterate_through_validationresult_details_to_log_each_rule_identifier_and_its_pass_or_fail_status.cs
+++ /dev/null
@@ -1,54 +0,0 @@
-// 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-variable-into-validator-in-memory-validation-scenarios.cs b/web-accessibility/load-html-content-from-string-variable-into-validator-in-memory-validation-scenarios.cs
new file mode 100644
index 0000000..3cc7dc4
--- /dev/null
+++ b/web-accessibility/load-html-content-from-string-variable-into-validator-in-memory-validation-scenarios.cs
@@ -0,0 +1,25 @@
+// Load HTML content from a string variable into the validator for in‑memory validation scenarios.
+
+public class Program
+{
+    public static void Main()
+    {
+        try
+        {
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><p>Hello World</p></body></html>";
+            string baseUri = "about:blank";
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, baseUri))
+            {
+                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);
+                System.Console.WriteLine("Validation completed.");
+            }
+        }
+        catch (System.Exception ex)
+        {
+            System.Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/load-html-content-string-create-document-object-run-accessibility-validation.cs b/web-accessibility/load-html-content-string-create-document-object-run-accessibility-validation.cs
new file mode 100644
index 0000000..cb960e6
--- /dev/null
+++ b/web-accessibility/load-html-content-string-create-document-object-run-accessibility-validation.cs
@@ -0,0 +1,39 @@
+// Load HTML content from a string, create a document object, and run accessibility validation.
+
+public class Program
+{
+    public static void Main(string[] args)
+    {
+        try
+        {
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1></body></html>";
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                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)
+                {
+                    System.Console.WriteLine("Accessibility validation succeeded.");
+                }
+                else
+                {
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (Aspose.Html.Accessibility.ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                System.Console.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (System.Exception ex)
+        {
+            System.Console.WriteLine(ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/load-html-file-from-disk-into-validator-using-load-method-with-file-path-argument.cs b/web-accessibility/load-html-file-from-disk-into-validator-using-load-method-with-file-path-argument.cs
new file mode 100644
index 0000000..19902c1
--- /dev/null
+++ b/web-accessibility/load-html-file-from-disk-into-validator-using-load-method-with-file-path-argument.cs
@@ -0,0 +1,34 @@
+// Load an HTML file from disk into the validator using the Load method with a file path argument.
+
+using System;
+using System.IO;
+
+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><p>Hello World</p></body></html>");
+            }
+
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath);
+
+            Aspose.Html.Accessibility.WebAccessibility webAcc = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAcc.CreateValidator();
+
+            Aspose.Html.Accessibility.Results.ValidationResult result = validator.Validate(document);
+
+            Console.WriteLine("Validation success: " + result.Success);
+            Console.WriteLine("Number of rule results: " + result.Details.Count);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/load-html-file-local-path-into-validator-wcag-analysis.cs b/web-accessibility/load-html-file-local-path-into-validator-wcag-analysis.cs
new file mode 100644
index 0000000..344b71c
--- /dev/null
+++ b/web-accessibility/load-html-file-local-path-into-validator-wcag-analysis.cs
@@ -0,0 +1,44 @@
+// Load an HTML file from a local path into the validator for WCAG analysis.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            string inputPath = "sample.html";
+            if (!File.Exists(inputPath))
+            {
+                string sampleHtml = "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello World</h1></body></html>";
+                File.WriteAllText(inputPath, sampleHtml);
+            }
+
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath);
+            Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+            if (!validationResult.Success)
+            {
+                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("Document passed all accessibility checks.");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/load-html-from-stream-into-validator-supporting-network-or-memorybased-sources.cs b/web-accessibility/load-html-from-stream-into-validator-supporting-network-or-memorybased-sources.cs
new file mode 100644
index 0000000..22e3856
--- /dev/null
+++ b/web-accessibility/load-html-from-stream-into-validator-supporting-network-or-memorybased-sources.cs
@@ -0,0 +1,79 @@
+// Load HTML from a Stream object into the validator to support network or memory‑based sources.
+
+using System;
+using System.IO;
+using System.Text;
+using System.Collections.Generic;
+using Aspose.Html.IO;
+
+class MemoryStreamProvider : Aspose.Html.IO.ICreateStreamProvider, IDisposable
+{
+    private readonly List<System.IO.MemoryStream> _streams = new List<System.IO.MemoryStream>();
+
+    public System.IO.Stream GetStream(string name, string extension)
+    {
+        var ms = new System.IO.MemoryStream();
+        _streams.Add(ms);
+        return ms;
+    }
+
+    public System.IO.Stream GetStream(string name, string extension, int page)
+    {
+        var ms = new System.IO.MemoryStream();
+        _streams.Add(ms);
+        return ms;
+    }
+
+    public void ReleaseStream(System.IO.Stream stream)
+    {
+        if (stream != null)
+        {
+            stream.Flush();
+        }
+    }
+
+    public System.Collections.Generic.IReadOnlyList<System.IO.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, World!</h1></body></html>";
+            System.IO.MemoryStream htmlStream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(html));
+            string baseUrl = "about:blank";
+
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlStream, baseUrl);
+
+            Aspose.Html.Saving.PdfSaveOptions options = new Aspose.Html.Saving.PdfSaveOptions();
+
+            MemoryStreamProvider provider = new MemoryStreamProvider();
+
+            Aspose.Html.Converters.Converter.ConvertHTML(document, options, provider);
+
+            if (provider.Streams.Count > 0)
+            {
+                System.IO.MemoryStream pdfStream = provider.Streams[0];
+                pdfStream.Position = 0;
+                using (System.IO.FileStream fileStream = new System.IO.FileStream("output.pdf", System.IO.FileMode.Create, System.IO.FileAccess.Write))
+                {
+                    pdfStream.CopyTo(fileStream);
+                }
+            }
+        }
+        catch (System.Exception ex)
+        {
+            System.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
deleted file mode 100644
index 7720678..0000000
--- a/web-accessibility/load_html_from_stream_object_into_validator_support_network_memory_sources.cs
+++ /dev/null
@@ -1,78 +0,0 @@
-// 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-all-validation-messages-to-file-for-further-analysis-and-troubleshooting-by-developers.cs b/web-accessibility/log-all-validation-messages-to-file-for-further-analysis-and-troubleshooting-by-developers.cs
new file mode 100644
index 0000000..f73f392
--- /dev/null
+++ b/web-accessibility/log-all-validation-messages-to-file-for-further-analysis-and-troubleshooting-by-developers.cs
@@ -0,0 +1,35 @@
+// Log all validation messages to a file for further analysis and troubleshooting by developers.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>";
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                string logPath = "validation_log.txt";
+                using (StreamWriter writer = new StreamWriter(logPath, true))
+                {
+                    writer.WriteLine("Validation Results - " + DateTime.Now);
+                    foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                    {
+                        writer.WriteLine(detail.ToString());
+                    }
+                    writer.WriteLine(new string('-', 40));
+                }
+            }
+            Console.WriteLine("Validation completed. Log written 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..b7f1223
--- /dev/null
+++ b/web-accessibility/modify-video-elements-include-keyboard-focusable-controls-add-tabindex-attributes-needed.cs
@@ -0,0 +1,37 @@
+// Modify video elements to include keyboard‑focusable controls by adding tabindex attributes where needed.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><video src='sample.mp4'></video><video src='sample2.mp4' tabindex='1'></video></body></html>";
+            string baseUri = "about:blank";
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, baseUri))
+            {
+                var elements = document.QuerySelectorAll("video");
+                for (int i = 0; i < elements.Length; i++)
+                {
+                    Aspose.Html.Dom.Element element = (Aspose.Html.Dom.Element)elements[i];
+                    string tabindex = element.GetAttribute("tabindex");
+                    if (string.IsNullOrEmpty(tabindex))
+                    {
+                        element.SetAttribute("tabindex", "0");
+                    }
+                }
+
+                string outputPath = "output.html";
+                document.Save(outputPath);
+                Console.WriteLine($"Modified HTML saved to {outputPath}");
+            }
+        }
+        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..59289bf
--- /dev/null
+++ b/web-accessibility/prioritize-remediation-tasks-severity-levels-advisory-technique-impact-scores.cs
@@ -0,0 +1,112 @@
+// Prioritize remediation tasks based on severity levels and advisory technique impact scores.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Collections;
+using Aspose.Html.Dom;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML with remediation tasks
+            string htmlContent = @"
+                <html>
+                <body>
+                    <div class='task' data-name='Update library' data-severity='High' data-score='75'>Task 1</div>
+                    <div class='task' data-name='Patch vulnerability' data-severity='Critical' data-score='90'>Task 2</div>
+                    <div class='task' data-name='Refactor code' data-severity='Medium' data-score='60'>Task 3</div>
+                    <div class='task' data-name='Improve logging' data-severity='Low' data-score='40'>Task 4</div>
+                </body>
+                </html>";
+
+            // Write HTML to a temporary file
+            string tempFilePath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".html");
+            File.WriteAllText(tempFilePath, htmlContent);
+
+            // Create Aspose.HTML configuration
+            Aspose.Html.Configuration configuration = new Aspose.Html.Configuration();
+
+            // Load the HTML document from the temporary file
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(tempFilePath, configuration))
+            {
+                // Select all task elements
+                Aspose.Html.Collections.NodeList taskNodes = document.QuerySelectorAll(".task");
+
+                List<RemediationTask> tasks = new List<RemediationTask>();
+
+                foreach (Element element in taskNodes)
+                {
+                    string name = element.GetAttribute("data-name");
+                    string severityStr = element.GetAttribute("data-severity");
+                    string scoreStr = element.GetAttribute("data-score");
+
+                    if (Enum.TryParse(severityStr, true, out Severity severity) && int.TryParse(scoreStr, out int score))
+                    {
+                        tasks.Add(new RemediationTask
+                        {
+                            Name = name,
+                            Severity = severity,
+                            ImpactScore = score
+                        });
+                    }
+                }
+
+                // Prioritize tasks: higher severity first, then higher impact score
+                tasks.Sort((a, b) =>
+                {
+                    int severityComparison = GetSeverityRank(b.Severity).CompareTo(GetSeverityRank(a.Severity));
+                    if (severityComparison != 0) return severityComparison;
+                    return b.ImpactScore.CompareTo(a.ImpactScore);
+                });
+
+                Console.WriteLine("Prioritized Remediation Tasks:");
+                foreach (var task in tasks)
+                {
+                    Console.WriteLine($"{task.Name} - Severity: {task.Severity}, Impact Score: {task.ImpactScore}");
+                }
+            }
+
+            // Clean up temporary file
+            if (File.Exists(tempFilePath))
+            {
+                File.Delete(tempFilePath);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+
+    static int GetSeverityRank(Severity severity)
+    {
+        switch (severity)
+        {
+            case Severity.Critical: return 4;
+            case Severity.High: return 3;
+            case Severity.Medium: return 2;
+            case Severity.Low: return 1;
+            default: return 0;
+        }
+    }
+}
+
+enum Severity
+{
+    Low,
+    Medium,
+    High,
+    Critical
+}
+
+class RemediationTask
+{
+    public string Name { get; set; }
+    public Severity Severity { get; set; }
+    public int ImpactScore { get; set; }
+}
\ No newline at end of file
diff --git a/web-accessibility/process-batch-html-files-folder-validating-each-file-sequentially-aggregating-results.cs b/web-accessibility/process-batch-html-files-folder-validating-each-file-sequentially-aggregating-results.cs
new file mode 100644
index 0000000..7905fb5
--- /dev/null
+++ b/web-accessibility/process-batch-html-files-folder-validating-each-file-sequentially-aggregating-results.cs
@@ -0,0 +1,61 @@
+// Process a batch of HTML files in a folder, validating each file sequentially and aggregating results.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Converters;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputFolder = "InputHtml";
+            string outputFolder = "OutputImages";
+            Directory.CreateDirectory(outputFolder);
+
+            int total = 0;
+            int success = 0;
+            int failure = 0;
+            List<string> errorMessages = new List<string>();
+
+            foreach (string htmlPath in Directory.GetFiles(inputFolder, "*.html"))
+            {
+                total++;
+                try
+                {
+                    using (HTMLDocument document = new HTMLDocument(htmlPath))
+                    {
+                        ImageSaveOptions options = new ImageSaveOptions(ImageFormat.Jpeg);
+                        string outputPath = Path.Combine(outputFolder, Path.GetFileNameWithoutExtension(htmlPath) + ".jpg");
+                        Aspose.Html.Converters.Converter.ConvertHTML(document, options, outputPath);
+                    }
+                    success++;
+                }
+                catch (Exception ex)
+                {
+                    failure++;
+                    errorMessages.Add($"File '{htmlPath}' error: {ex.Message}");
+                }
+            }
+
+            Console.WriteLine($"Processed {total} files. Success: {success}, Failed: {failure}.");
+            if (errorMessages.Count > 0)
+            {
+                Console.WriteLine("Errors:");
+                foreach (string msg in errorMessages)
+                {
+                    Console.WriteLine(msg);
+                }
+            }
+        }
+        catch (Exception e)
+        {
+            Console.WriteLine($"Unexpected error: {e.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/process-html-files-in-parallel-using-task-parallel-library-improve-validation-throughput-large-projects.cs b/web-accessibility/process-html-files-in-parallel-using-task-parallel-library-improve-validation-throughput-large-projects.cs
new file mode 100644
index 0000000..32f3b5e
--- /dev/null
+++ b/web-accessibility/process-html-files-in-parallel-using-task-parallel-library-improve-validation-throughput-large-projects.cs
@@ -0,0 +1,30 @@
+// Process HTML files in parallel using Task Parallel Library to improve validation throughput for large projects.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputFolder = "InputHtml";
+            string outputFolder = "OutputImages";
+            System.IO.Directory.CreateDirectory(outputFolder);
+            string[] htmlFiles = System.IO.Directory.GetFiles(inputFolder, "*.html");
+            System.Threading.Tasks.Parallel.ForEach(htmlFiles, htmlPath =>
+            {
+                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 = System.IO.Path.Combine(outputFolder, System.IO.Path.GetFileNameWithoutExtension(htmlPath) + ".jpg");
+                    Aspose.Html.Converters.Converter.ConvertHTML(document, options, outputPath);
+                }
+            });
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/process-html-folder-validate-each-output-individual-json-reports-target-directory.cs b/web-accessibility/process-html-folder-validate-each-output-individual-json-reports-target-directory.cs
new file mode 100644
index 0000000..f06cb87
--- /dev/null
+++ b/web-accessibility/process-html-folder-validate-each-output-individual-json-reports-target-directory.cs
@@ -0,0 +1,64 @@
+// Process a folder of HTML files, validate each, and output individual JSON reports to a target directory.
+
+using System;
+using System.IO;
+using System.Text.Json;
+using Aspose.Html;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            string inputFolder = "InputHtml";
+            string outputFolder = "ValidationReports";
+
+            // Ensure input folder exists and contains at least one sample file
+            Directory.CreateDirectory(inputFolder);
+            if (Directory.GetFiles(inputFolder, "*.html").Length == 0)
+            {
+                string samplePath = Path.Combine(inputFolder, "sample.html");
+                File.WriteAllText(samplePath, "<!DOCTYPE html><html><head><title>Sample</title></head><body><p>Hello, World!</p></body></html>");
+            }
+
+            // Prepare output directory
+            Directory.CreateDirectory(outputFolder);
+
+            foreach (string htmlPath in Directory.GetFiles(inputFolder, "*.html"))
+            {
+                bool isValid = false;
+                string errorMessage = null;
+
+                try
+                {
+                    using (HTMLDocument document = new HTMLDocument(htmlPath))
+                    {
+                        // If loading succeeds, consider the HTML valid
+                        isValid = true;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    isValid = false;
+                    errorMessage = ex.Message;
+                }
+
+                var report = new
+                {
+                    File = Path.GetFileName(htmlPath),
+                    IsValid = isValid,
+                    Error = errorMessage
+                };
+
+                string json = JsonSerializer.Serialize(report, new JsonSerializerOptions { WriteIndented = true });
+                string jsonPath = Path.Combine(outputFolder, Path.GetFileNameWithoutExtension(htmlPath) + ".json");
+                File.WriteAllText(jsonPath, json);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ 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
deleted file mode 100644
index e079b3f..0000000
--- a/web-accessibility/process_batch_html_files_in_folder_validating_each_file_sequentially_aggregating_results.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-// 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
deleted file mode 100644
index 8b89ceb..0000000
--- a/web-accessibility/process_html_files_parallel_using_task_parallel_library_improve_validation_throughput_large_projects.cs
+++ /dev/null
@@ -1,151 +0,0 @@
-// 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
deleted file mode 100644
index 6125faf..0000000
--- a/web-accessibility/process_html_folder_validate_each_output_individual_json_reports_to_target_directory.cs
+++ /dev/null
@@ -1,79 +0,0 @@
-// 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
similarity index 67%
rename from web-accessibility/publish_validation_summaries_to_dashboard_for_continuous_monitoring_website_accessibility_status.cs
rename to web-accessibility/publish-validation-summaries-to-dashboard-for-continuous-monitoring-website-accessibility-status.cs
index 91e190e..8a45c67 100644
--- 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
@@ -1,7 +1,6 @@
 // Publish validation summaries to a dashboard for continuous monitoring of website accessibility status.
 
 using System;
-using System.IO;
 
 class Program
 {
@@ -9,21 +8,19 @@ 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
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src='image.jpg'></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(tempFile))
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
             {
                 Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
-
-                if (!validationResult.Success)
+                if (validationResult.Success)
+                {
+                    System.Console.WriteLine("Accessibility validation passed. No issues found.");
+                }
+                else
                 {
+                    System.Console.WriteLine("Accessibility validation failed. Summary:");
                     foreach (Aspose.Html.Accessibility.Results.RuleValidationResult ruleResult in validationResult.Details)
                     {
                         if (!ruleResult.Success)
@@ -35,31 +32,21 @@ static void Main()
                                     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}");
+                                    System.Console.WriteLine($"Tag: {tagName}, Attribute (alt): {attributeValue}, Message: {techResult.Error.ErrorMessage}");
                                 }
                                 else
                                 {
-                                    Console.WriteLine($"Message: {techResult.Error.ErrorMessage}");
+                                    System.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}");
+            System.Console.WriteLine($"Error: {ex.Message}");
         }
     }
 }
\ No newline at end of file
diff --git a/web-accessibility/query-specific-rule-by-code-using-accessibilityrules-getrule-show-detailed-guidance.cs b/web-accessibility/query-specific-rule-by-code-using-accessibilityrules-getrule-show-detailed-guidance.cs
new file mode 100644
index 0000000..a64578c
--- /dev/null
+++ b/web-accessibility/query-specific-rule-by-code-using-accessibilityrules-getrule-show-detailed-guidance.cs
@@ -0,0 +1,52 @@
+// Query a specific rule by code using AccessibilityRules.GetRule to show detailed guidance.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Initialize WebAccessibility object
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+            // Get a principle by its code (example code "1.1")
+            Aspose.Html.Accessibility.Principle principle = webAccessibility.Rules.GetPrinciple("1.1");
+            if (principle == null)
+            {
+                Console.WriteLine("Principle with the specified code was not found.");
+                return;
+            }
+
+            // Get a guideline from the principle (example code "1.1.1")
+            Aspose.Html.Accessibility.Guideline guideline = principle.GetGuideline("1.1.1");
+            if (guideline == null)
+            {
+                Console.WriteLine("Guideline with the specified code was not found.");
+                return;
+            }
+
+            // Get a criterion from the guideline (example code "1.1.1.1")
+            Aspose.Html.Accessibility.Criterion criterion = guideline.GetCriterion("1.1.1.1");
+            if (criterion == null)
+            {
+                Console.WriteLine("Criterion with the specified code was not found.");
+                return;
+            }
+
+            // Output criterion details
+            Console.WriteLine("{0}:{1} - {2}", criterion.Code, criterion.Description, criterion.Level);
+
+            // List sufficient techniques (rules) for the criterion
+            foreach (Aspose.Html.Accessibility.IRule technique in criterion.SufficientTechniques)
+            {
+                Console.WriteLine("{0}:{1}", technique.Code, technique.Description);
+            }
+        }
+        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
deleted file mode 100644
index e4d3b72..0000000
--- a/web-accessibility/query_specific_rule_by_code_accessibilityrules_getrule_show_detailed_guidance.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-// 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-to-confirm-previously-reported-issues-resolved.cs
similarity index 58%
rename from web-accessibility/re_run_validation_after_html_modifications_confirm_previously_reported_issues_resolved.cs
rename to web-accessibility/re-run-validation-after-html-modifications-to-confirm-previously-reported-issues-resolved.cs
index 39e1191..1e962bd 100644
--- a/web-accessibility/re_run_validation_after_html_modifications_confirm_previously_reported_issues_resolved.cs
+++ b/web-accessibility/re-run-validation-after-html-modifications-to-confirm-previously-reported-issues-resolved.cs
@@ -1,8 +1,6 @@
 // Re‑run validation after HTML modifications to confirm that previously reported issues are resolved.
 
 using System;
-using System.IO;
-using System.Text;
 
 class Program
 {
@@ -10,25 +8,13 @@ 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>";
+            // Sample HTML content (could be modified as needed)
+            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Welcome</h1></body></html>";
 
-            // Write content to a temporary file
-            string tempFilePath = Path.Combine(Path.GetTempPath(), "sample.html");
-            File.WriteAllText(tempFilePath, htmlContent, Encoding.UTF8);
+            // Load HTML content into a document (use two‑argument constructor to avoid file‑not‑found errors)
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank");
 
-            // Load the HTML document
-            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(tempFilePath);
-
-            // Create WebAccessibility instance and validator
+            // Create WebAccessibility instance 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);
 
@@ -42,15 +28,15 @@ static void Main()
                 {
                     if (!detail.Success)
                     {
-                        Console.WriteLine($"{detail.Rule.Code}: {detail.Rule.Description}");
+                        System.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}");
+                            System.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}");
+                                System.Console.WriteLine("Element: " + element.OuterHTML);
                             }
                         }
                     }
@@ -58,18 +44,12 @@ static void Main()
             }
             else
             {
-                Console.WriteLine("Accessibility validation succeeded with no errors.");
-            }
-
-            // Clean up temporary file
-            if (File.Exists(tempFilePath))
-            {
-                File.Delete(tempFilePath);
+                System.Console.WriteLine("Validation succeeded. No accessibility issues found.");
             }
         }
         catch (Exception ex)
         {
-            Console.WriteLine($"An error occurred: {ex.Message}");
+            System.Console.WriteLine("An error occurred: " + ex.Message);
         }
     }
 }
\ No newline at end of file
diff --git a/web-accessibility/read-validationresult-description-high-level-summary-accessibility-check-outcome.cs b/web-accessibility/read-validationresult-description-high-level-summary-accessibility-check-outcome.cs
new file mode 100644
index 0000000..a401293
--- /dev/null
+++ b/web-accessibility/read-validationresult-description-high-level-summary-accessibility-check-outcome.cs
@@ -0,0 +1,71 @@
+// Read ValidationResult.Description to obtain a high‑level summary of the accessibility check outcome.
+
+using System;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+using Aspose.Html;
+using Aspose.Html.IO;
+
+namespace AsposeHtmlAccessibilityExample
+{
+    class Program
+    {
+        static void Main()
+        {
+            try
+            {
+                // Sample HTML content
+                string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><img src='image.png'></body></html>";
+
+                // Initialize accessibility validator
+                WebAccessibility webAccessibility = new WebAccessibility();
+                AccessibilityValidator validator = webAccessibility.CreateValidator(ValidationBuilder.All);
+
+                // Load HTML document from inline content
+                using (HTMLDocument document = new HTMLDocument(htmlContent, "about:blank"))
+                {
+                    ValidationResult validationResult = validator.Validate(document);
+
+                    // High‑level summary (fallback since Description property is unavailable)
+                    if (validationResult.Success)
+                    {
+                        Console.WriteLine("Accessibility check passed.");
+                    }
+                    else
+                    {
+                        Console.WriteLine("Accessibility check failed.");
+                    }
+
+                    // Detailed error information
+                    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;
+                                        string attributeValue = element.GetAttribute("alt");
+                                        Console.WriteLine($"Tag: {tagName}, Attribute: {attributeValue}, Message: {techResult.Error.ErrorMessage}");
+                                    }
+                                    else
+                                    {
+                                        Console.WriteLine(techResult.Error.ErrorMessage);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error: {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
deleted file mode 100644
index 5bfd7af..0000000
--- a/web-accessibility/read_validationresult_description_obtain_high_level_summary_accessibility_check_outcome.cs
+++ /dev/null
@@ -1,81 +0,0 @@
-// 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-validation-issues-log-file-persistent-storage.cs b/web-accessibility/redirect-console-output-validation-issues-log-file-persistent-storage.cs
new file mode 100644
index 0000000..2433b02
--- /dev/null
+++ b/web-accessibility/redirect-console-output-validation-issues-log-file-persistent-storage.cs
@@ -0,0 +1,43 @@
+// Redirect console output of validation issues to a log file for persistent storage.
+
+using System;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1></body></html>";
+        string logPath = "validation_log.txt";
+
+        try
+        {
+            using (StreamWriter logWriter = new StreamWriter(logPath, false))
+            {
+                logWriter.AutoFlush = true;
+                TextWriter originalOut = Console.Out;
+                Console.SetOut(logWriter);
+
+                using (HTMLDocument document = new HTMLDocument(htmlContent, "about:blank"))
+                {
+                    AccessibilityValidator validator = new WebAccessibility().CreateValidator();
+                    ValidationResult result = validator.Validate(document);
+
+                    foreach (RuleValidationResult detail in result.Details)
+                    {
+                        Console.WriteLine(detail.ToString());
+                    }
+                }
+
+                Console.SetOut(originalOut);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/retrieve-contrast-ratio-values-specific-foreground-background-colors-log-any-failures.cs b/web-accessibility/retrieve-contrast-ratio-values-specific-foreground-background-colors-log-any-failures.cs
new file mode 100644
index 0000000..168138e
--- /dev/null
+++ b/web-accessibility/retrieve-contrast-ratio-values-specific-foreground-background-colors-log-any-failures.cs
@@ -0,0 +1,72 @@
+// Retrieve contrast ratio values for specific foreground and background colors and log any failures.
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML document creation using Aspose.HTML (demonstration purpose)
+            string htmlContent = "<html><body><p>Sample</p></body></html>";
+            using (Aspose.Html.HTMLDocument doc = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                // Document is not used further; just ensures Aspose.HTML usage.
+            }
+
+            // Define foreground and background color pairs to test
+            var colorPairs = new List<Tuple<Color, Color>>
+            {
+                Tuple.Create(Color.Black, Color.White),
+                Tuple.Create(Color.DarkGray, Color.LightGray),
+                Tuple.Create(Color.FromArgb(255, 0, 0), Color.FromArgb(255, 255, 0)), // red on yellow
+                Tuple.Create(Color.FromArgb(0, 128, 0), Color.FromArgb(255, 255, 255)), // green on white
+                Tuple.Create(Color.FromArgb(255, 255, 255), Color.FromArgb(255, 255, 255)) // white on white (failure)
+            };
+
+            const double minimumContrast = 4.5; // WCAG AA for normal text
+
+            for (int i = 0; i < colorPairs.Count; i++)
+            {
+                Color fore = colorPairs[i].Item1;
+                Color back = colorPairs[i].Item2;
+                double ratio = ComputeContrastRatio(fore, back);
+                string result = ratio >= minimumContrast ? "PASS" : "FAIL";
+                Console.WriteLine($"Pair {i + 1}: Foreground={fore}, Background={back}, Contrast Ratio={ratio:F2} - {result}");
+                if (result == "FAIL")
+                {
+                    Console.WriteLine($"  Failure: Contrast ratio {ratio:F2} is below the required {minimumContrast}");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+
+    static double ComputeContrastRatio(Color fore, Color back)
+    {
+        double l1 = ComputeRelativeLuminance(fore);
+        double l2 = ComputeRelativeLuminance(back);
+        double lighter = Math.Max(l1, l2);
+        double darker = Math.Min(l1, l2);
+        return (lighter + 0.05) / (darker + 0.05);
+    }
+
+    static double ComputeRelativeLuminance(Color color)
+    {
+        double RsRGB = color.R / 255.0;
+        double GsRGB = color.G / 255.0;
+        double BsRGB = color.B / 255.0;
+
+        double R = RsRGB <= 0.03928 ? RsRGB / 12.92 : Math.Pow((RsRGB + 0.055) / 1.055, 2.4);
+        double G = GsRGB <= 0.03928 ? GsRGB / 12.92 : Math.Pow((GsRGB + 0.055) / 1.055, 2.4);
+        double B = BsRGB <= 0.03928 ? BsRGB / 12.92 : Math.Pow((BsRGB + 0.055) / 1.055, 2.4);
+
+        return 0.2126 * R + 0.7152 * G + 0.0722 * B;
+    }
+}
\ 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/retrieve-validationresult-returned-by-validate-and-store-for-further-processing.cs
similarity index 50%
rename from web-accessibility/integrate_validation_step_into_ci_cd_pipeline_using_command_line_invocation_validator.cs
rename to web-accessibility/retrieve-validationresult-returned-by-validate-and-store-for-further-processing.cs
index dd28bed..d6a5f53 100644
--- a/web-accessibility/integrate_validation_step_into_ci_cd_pipeline_using_command_line_invocation_validator.cs
+++ b/web-accessibility/retrieve-validationresult-returned-by-validate-and-store-for-further-processing.cs
@@ -1,42 +1,30 @@
-// Integrate the validation step into a CI/CD pipeline using a command‑line invocation of the validator.
+// Retrieve the ValidationResult returned by Validate and store it for further processing.
 
 using System;
-using System.IO;
-using System.Text;
 
 class Program
 {
-    static void Main()
+    static void Main(string[] args)
     {
         try
         {
             // Sample HTML content
-            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello, world!</h1></body></html>";
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>";
+            string baseUri = "about:blank";
 
-            // Load the HTML document from the string
-            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent))
+            // Load HTML document from string content
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, baseUri))
             {
-                // Create a WebAccessibility instance
+                // 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);
 
-                // Create a validator (default validation rules)
-                Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator();
-
-                // Perform validation
+                // Perform validation and store the result
                 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
+                // Process validation result
                 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}");
@@ -47,13 +35,13 @@ static void Main()
                 }
                 else
                 {
-                    Console.WriteLine("Validation succeeded.");
+                    Console.WriteLine("HTML document passed all accessibility validation rules.");
                 }
             }
         }
         catch (Exception ex)
         {
-            Console.WriteLine($"Error: {ex.Message}");
+            Console.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
deleted file mode 100644
index 8a34af7..0000000
--- a/web-accessibility/retrieve_contrast_ratio_values_for_specific_foreground_and_background_colors_log_failures.cs
+++ /dev/null
@@ -1,117 +0,0 @@
-// 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
deleted file mode 100644
index 520bc2e..0000000
--- a/web-accessibility/retrieve_validationresult_returned_by_validate_and_store_for_further_processing.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-// 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-produce-consolidated-json-report.cs b/web-accessibility/run-batch-validation-on-all-html-files-in-project-folder-produce-consolidated-json-report.cs
new file mode 100644
index 0000000..d5bbfc6
--- /dev/null
+++ b/web-accessibility/run-batch-validation-on-all-html-files-in-project-folder-produce-consolidated-json-report.cs
@@ -0,0 +1,61 @@
+// Run batch validation on all HTML files in a project folder and produce a consolidated JSON report.
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Text.Json;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+using Aspose.Html;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string inputFolder = "HTMLFiles";
+            string outputJsonPath = "validation_report.json";
+
+            // Ensure input folder exists
+            if (!Directory.Exists(inputFolder))
+            {
+                Directory.CreateDirectory(inputFolder);
+                // Create a minimal sample HTML file
+                string samplePath = Path.Combine(inputFolder, "sample.html");
+                File.WriteAllText(samplePath, "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Hello World</h1></body></html>");
+            }
+
+            // Prepare validator
+            WebAccessibility webAccessibility = new WebAccessibility();
+            AccessibilityValidator validator = webAccessibility.CreateValidator(ValidationBuilder.All);
+
+            // Collect results
+            List<object> report = new List<object>();
+
+            string[] htmlFiles = Directory.GetFiles(inputFolder, "*.html", SearchOption.AllDirectories);
+            foreach (string filePath in htmlFiles)
+            {
+                using (HTMLDocument document = new HTMLDocument(filePath))
+                {
+                    ValidationResult validationResult = validator.Validate(document);
+                    string xmlResult = validationResult.ToString();
+
+                    report.Add(new
+                    {
+                        File = filePath,
+                        ValidationXml = xmlResult
+                    });
+                }
+            }
+
+            // Serialize to JSON
+            string json = JsonSerializer.Serialize(report, new JsonSerializerOptions { WriteIndented = true });
+            File.WriteAllText(outputJsonPath, json);
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/run-default-accessibility-validation-and-direct-console-output-to-debug-logger-for-development-monitoring.cs b/web-accessibility/run-default-accessibility-validation-and-direct-console-output-to-debug-logger-for-development-monitoring.cs
new file mode 100644
index 0000000..e051a94
--- /dev/null
+++ b/web-accessibility/run-default-accessibility-validation-and-direct-console-output-to-debug-logger-for-development-monitoring.cs
@@ -0,0 +1,51 @@
+// Run default accessibility validation and direct console output to a debug logger for development monitoring.
+
+using System;
+using System.Diagnostics;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+using Aspose.Html;
+
+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 accessibility validator
+            WebAccessibility webAccessibility = new WebAccessibility();
+            AccessibilityValidator validator = webAccessibility.CreateValidator(ValidationBuilder.All);
+
+            // Load HTML document from inline content
+            using (HTMLDocument document = new HTMLDocument(htmlContent, "about:blank"))
+            {
+                ValidationResult validationResult = validator.Validate(document);
+
+                if (validationResult.Success)
+                {
+                    Debug.WriteLine("Accessibility validation passed.");
+                }
+                else
+                {
+                    foreach (RuleValidationResult ruleResult in validationResult.Details)
+                    {
+                        if (!ruleResult.Success)
+                        {
+                            foreach (ITechniqueResult techResult in ruleResult.Errors)
+                            {
+                                Debug.WriteLine(techResult.Error.ErrorMessage);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        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-as-part-of-nightly-build-process-to-ensure-continuous-accessibility-compliance.cs
similarity index 59%
rename from web-accessibility/run_validation_nightly_build_process_ensure_continuous_accessibility_compliance.cs
rename to web-accessibility/run-validation-as-part-of-nightly-build-process-to-ensure-continuous-accessibility-compliance.cs
index 361c7b9..1cbeb01 100644
--- a/web-accessibility/run_validation_nightly_build_process_ensure_continuous_accessibility_compliance.cs
+++ b/web-accessibility/run-validation-as-part-of-nightly-build-process-to-ensure-continuous-accessibility-compliance.cs
@@ -4,28 +4,20 @@
 
 class Program
 {
-    static void Main()
+    static void Main(string[] args)
     {
         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))
+            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Accessibility Test</h1></body></html>";
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
             {
-                // Perform 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);
 
                 if (validationResult.Success)
                 {
-                    Console.WriteLine("Document passed accessibility validation.");
+                    Console.WriteLine("Accessibility validation passed.");
                 }
                 else
                 {
@@ -44,7 +36,7 @@ static void Main()
         }
         catch (Exception ex)
         {
-            Console.WriteLine($"Error: {ex.Message}");
+            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
deleted file mode 100644
index 81506a1..0000000
--- a/web-accessibility/run_batch_validation_on_all_html_files_in_project_folder_and_produce_consolidated_json_report.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-// 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
deleted file mode 100644
index 74b593e..0000000
--- a/web-accessibility/run_default_accessibility_validation_direct_console_output_debug_logger_development_monitoring.cs
+++ /dev/null
@@ -1,130 +0,0 @@
-// 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/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..033843f
--- /dev/null
+++ b/web-accessibility/save-complete-validation-report-to-string-using-validationresult-savetostring-method-for-later-processing.cs
@@ -0,0 +1,25 @@
+// Save the complete validation report to a string using ValidationResult.SaveToString method for later processing.
+
+namespace Example
+{
+    class Program
+    {
+        static void Main()
+        {
+            try
+            {
+                string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1></body></html>";
+                string baseUri = "about:blank";
+                Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, baseUri);
+                Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+                string report = validationResult.SaveToString();
+                System.Console.WriteLine(report);
+            }
+            catch (System.Exception ex)
+            {
+                System.Console.WriteLine("Error: " + 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..c065afe
--- /dev/null
+++ b/web-accessibility/save-validation-results-to-json-file-for-later-analysis-and-integration-with-reporting-tools.cs
@@ -0,0 +1,47 @@
+// Save validation results to a JSON file for later analysis and integration with reporting tools.
+
+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(string[] args)
+    {
+        try
+        {
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>";
+
+            // Load HTML document from inline content
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                // Create accessibility validator
+                Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                // Save validation result as JSON string
+                using (StringWriter sw = new StringWriter())
+                {
+                    validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.JSON);
+                    string jsonContent = sw.ToString();
+
+                    // Write JSON to file
+                    string jsonPath = "validation_results.json";
+                    File.WriteAllText(jsonPath, jsonContent);
+
+                    Console.WriteLine($"Validation results saved to: {jsonPath}");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/save-validation-results-xml-file-compatibility-legacy-systems-workflows.cs b/web-accessibility/save-validation-results-xml-file-compatibility-legacy-systems-workflows.cs
new file mode 100644
index 0000000..13d08dc
--- /dev/null
+++ b/web-accessibility/save-validation-results-xml-file-compatibility-legacy-systems-workflows.cs
@@ -0,0 +1,48 @@
+// Save validation results to an XML file for compatibility with legacy systems and workflows.
+
+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
+        {
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>";
+
+            // Load HTML document from inline content
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                // Create accessibility validator
+                Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+                Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator();
+
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                // Save validation result to XML string
+                using (StringWriter sw = new StringWriter())
+                {
+                    validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                    string xmlContent = sw.ToString();
+
+                    // Write XML to file
+                    string outputPath = "validation_result.xml";
+                    File.WriteAllText(outputPath, xmlContent);
+                    Console.WriteLine($"Validation results saved to: {Path.GetFullPath(outputPath)}");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("An error occurred:");
+            Console.WriteLine(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
deleted file mode 100644
index 59b3404..0000000
--- a/web-accessibility/save_complete_validation_report_to_string_using_validationresult_savetostring_method_for_later_processing.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-// 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
deleted file mode 100644
index dcb9311..0000000
--- a/web-accessibility/save_validation_results_to_json_file_for_later_analysis_and_integration_with_reporting_tools.cs
+++ /dev/null
@@ -1,96 +0,0 @@
-// 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/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..a5a84fe
--- /dev/null
+++ b/web-accessibility/schedule-windows-task-scheduler-job-runs-batch-validation-all-html-files-nightly.cs
@@ -0,0 +1,31 @@
+// Schedule a Windows Task Scheduler job that runs batch validation on all HTML files nightly.
+
+namespace MyApp
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            try
+            {
+                string inputFolder = "InputHtml";
+                string outputFolder = "OutputImages";
+                System.IO.Directory.CreateDirectory(inputFolder);
+                System.IO.Directory.CreateDirectory(outputFolder);
+                foreach (string htmlPath in System.IO.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 = System.IO.Path.Combine(outputFolder, System.IO.Path.GetFileNameWithoutExtension(htmlPath) + ".jpg");
+                        Aspose.Html.Converters.Converter.ConvertHTML(document, options, 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
deleted file mode 100644
index f953cd1..0000000
--- a/web-accessibility/schedule_windows_task_scheduler_job_runs_batch_validation_all_html_files_nightly.cs
+++ /dev/null
@@ -1,64 +0,0 @@
-// 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..e5b36ff
--- /dev/null
+++ b/web-accessibility/select-desired-output-format-enumeration-before-saving-results.cs
@@ -0,0 +1,115 @@
+// Select the desired output format by using the ValidationResultSaveFormat enumeration before saving results.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Prepare a minimal MHTML file
+            string inputMhtmlPath = "sample.mht";
+            if (!File.Exists(inputMhtmlPath))
+            {
+                // Simple MHTML content (HTML wrapped in MIME format)
+                string mhtmlContent = @"From: <Saved by WebKit>
+Subject: 
+Date: Mon, 01 Jan 2024 00:00:00 GMT
+MIME-Version: 1.0
+Content-Type: multipart/related; boundary=""----=_NextPart_000_0000""; type=""text/html""
+
+------=_NextPart_000_0000
+Content-Type: text/html; charset=""utf-8""
+Content-Transfer-Encoding: quoted-printable
+
+<html><body><h1>Hello, MHTML!</h1></body></html>
+
+------=_NextPart_000_0000--";
+                File.WriteAllText(inputMhtmlPath, mhtmlContent);
+            }
+
+            // Convert to desired format
+            string format = "JPEG"; // Change to "XPS" or "DOCX" as needed
+            string outputPath = ConvertMhtmlByFormat(inputMhtmlPath, format);
+            Console.WriteLine($"Conversion completed. Output file: {outputPath}");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+
+    static string ConvertMhtmlByFormat(string inputPath, string format)
+    {
+        if (string.IsNullOrEmpty(inputPath))
+            throw new ArgumentException("Input path is null or empty.", nameof(inputPath));
+
+        if (string.IsNullOrEmpty(format))
+            throw new ArgumentException("Format is null or empty.", nameof(format));
+
+        string upperFormat = format.Trim().ToUpperInvariant();
+        string outputPath;
+
+        switch (upperFormat)
+        {
+            case "XPS":
+                {
+                    var options = new Aspose.Html.Saving.XpsSaveOptions();
+                    outputPath = Path.ChangeExtension(inputPath, ".xps");
+                    Aspose.Html.Converters.Converter.ConvertMHTML(inputPath, options, outputPath);
+                    break;
+                }
+            case "DOCX":
+                {
+                    var options = new Aspose.Html.Saving.DocSaveOptions();
+                    outputPath = Path.ChangeExtension(inputPath, ".docx");
+                    Aspose.Html.Converters.Converter.ConvertMHTML(inputPath, options, outputPath);
+                    break;
+                }
+            case "JPEG":
+                {
+                    var imageFormat = Aspose.Html.Rendering.Image.ImageFormat.Jpeg;
+                    var options = new Aspose.Html.Saving.ImageSaveOptions(imageFormat);
+                    outputPath = Path.ChangeExtension(inputPath, ".jpg");
+                    Aspose.Html.Converters.Converter.ConvertMHTML(inputPath, options, outputPath);
+                    break;
+                }
+            default:
+                throw new NotSupportedException($"The format '{format}' is not supported.");
+        }
+
+        // Optionally, you can retrieve MIME type using helpers
+        // string mime = GetMimeTypeForDocumentOptions(options);
+        // Console.WriteLine($"MIME type: {mime}");
+
+        return outputPath;
+    }
+
+    static string GetMimeTypeForDocumentOptions(object options)
+    {
+        if (options is Aspose.Html.Saving.PdfSaveOptions)
+            return "application/pdf";
+        if (options is Aspose.Html.Saving.DocSaveOptions)
+            return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+        if (options is Aspose.Html.Saving.XpsSaveOptions)
+            return "application/vnd.ms-xpsdocument";
+        return "application/octet-stream";
+    }
+
+    static string GetMimeTypeForImageFormat(Aspose.Html.Rendering.Image.ImageFormat format)
+    {
+        if (format == Aspose.Html.Rendering.Image.ImageFormat.Jpeg)
+            return "image/jpeg";
+        if (format == Aspose.Html.Rendering.Image.ImageFormat.Png)
+            return "image/png";
+        if (format == Aspose.Html.Rendering.Image.ImageFormat.Gif)
+            return "image/gif";
+        if (format == Aspose.Html.Rendering.Image.ImageFormat.Bmp)
+            return "image/bmp";
+        if (format == Aspose.Html.Rendering.Image.ImageFormat.Tiff)
+            return "image/tiff";
+        return "application/octet-stream";
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/serialize-validationresult-to-json-custom-serialization-for-external-integration.cs b/web-accessibility/serialize-validationresult-to-json-custom-serialization-for-external-integration.cs
new file mode 100644
index 0000000..da3835d
--- /dev/null
+++ b/web-accessibility/serialize-validationresult-to-json-custom-serialization-for-external-integration.cs
@@ -0,0 +1,33 @@
+// Serialize the ValidationResult to JSON using custom serialization for external tool integration.
+
+namespace Example
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            try
+            {
+                string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1></body></html>";
+                using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+                {
+                    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.Text.Json.Nodes.JsonObject jsonObj = new System.Text.Json.Nodes.JsonObject();
+                        jsonObj["validationResultXml"] = xml;
+                        string json = jsonObj.ToJsonString();
+                        System.Console.WriteLine(json);
+                    }
+                }
+            }
+            catch (System.Exception ex)
+            {
+                System.Console.Error.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/serialize-validationresult-xml-custom-serialization-legacy-system-compatibility.cs
similarity index 54%
rename from web-accessibility/write_validation_results_to_xml_using_validationresult_saveto_xml_format.cs
rename to web-accessibility/serialize-validationresult-xml-custom-serialization-legacy-system-compatibility.cs
index 86a592b..106b1ad 100644
--- a/web-accessibility/write_validation_results_to_xml_using_validationresult_saveto_xml_format.cs
+++ b/web-accessibility/serialize-validationresult-xml-custom-serialization-legacy-system-compatibility.cs
@@ -1,7 +1,11 @@
-// Write validation results to an XML file by calling ValidationResult.SaveTo with Xml format.
+// Serialize the ValidationResult to XML using custom serialization for legacy system compatibility.
 
 using System;
 using System.IO;
+using Aspose.Html;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+using Aspose.Html.Accessibility.Saving;
 
 class Program
 {
@@ -9,28 +13,29 @@ 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>";
+            // Prepare a minimal HTML file
             string inputPath = "sample.html";
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1></body></html>";
             File.WriteAllText(inputPath, htmlContent);
 
+            // Load the document
             using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(inputPath))
             {
+                // Create validator and perform validation
                 Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
                 Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
 
+                // Serialize validation result to XML
                 using (StringWriter sw = new StringWriter())
                 {
                     validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
-                    Console.WriteLine("Accessibility validation result (XML):");
-                    Console.WriteLine(sw.ToString());
-                }
-            }
+                    string xml = sw.ToString();
 
-            // Clean up the temporary file
-            if (File.Exists(inputPath))
-            {
-                File.Delete(inputPath);
+                    // Save XML to file (custom serialization for legacy system)
+                    string outputPath = "validation_result.xml";
+                    File.WriteAllText(outputPath, xml);
+                    Console.WriteLine("Validation result saved to: " + outputPath);
+                }
             }
         }
         catch (Exception ex)
diff --git a/web-accessibility/set-custom-issue-severity-threshold-only-high-priority-accessibility-problems-reported.cs b/web-accessibility/set-custom-issue-severity-threshold-only-high-priority-accessibility-problems-reported.cs
new file mode 100644
index 0000000..4b1429f
--- /dev/null
+++ b/web-accessibility/set-custom-issue-severity-threshold-only-high-priority-accessibility-problems-reported.cs
@@ -0,0 +1,57 @@
+// 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.jpg'></body></html>";
+
+            // Initialize WebAccessibility and create a validator with 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 HTML document from inline content
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                // 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;
+                                    System.Console.WriteLine($"Tag: {tagName}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                                else
+                                {
+                                    System.Console.WriteLine($"Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    System.Console.WriteLine("No accessibility issues found.");
+                }
+            }
+        }
+        catch (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
deleted file mode 100644
index b876aac..0000000
--- a/web-accessibility/set_custom_issue_severity_threshold_high_priority_accessibility_problems.cs
+++ /dev/null
@@ -1,79 +0,0 @@
-// 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..a4fe930
--- /dev/null
+++ b/web-accessibility/stream-validation-results-to-network-socket-using-custom-textwriter-for-remote-monitoring.cs
@@ -0,0 +1,70 @@
+// Stream validation results to a network socket using a custom TextWriter for remote monitoring.
+
+using System;
+using System.IO;
+using System.Net.Sockets;
+using System.Text;
+using Aspose.Html;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+using Aspose.Html.Accessibility.Saving;
+
+class NetworkTextWriter : TextWriter
+{
+    private readonly NetworkStream _stream;
+    public NetworkTextWriter(NetworkStream stream) { _stream = stream; }
+    public override Encoding Encoding => Encoding.UTF8;
+    public override void Write(char value)
+    {
+        byte[] buffer = Encoding.GetBytes(new char[] { value });
+        _stream.Write(buffer, 0, buffer.Length);
+    }
+    public override void Write(string value)
+    {
+        if (value == null) return;
+        byte[] buffer = Encoding.GetBytes(value);
+        _stream.Write(buffer, 0, buffer.Length);
+    }
+    public override void WriteLine(string value)
+    {
+        Write(value + Environment.NewLine);
+    }
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            _stream?.Dispose();
+        }
+        base.Dispose(disposing);
+    }
+}
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Sample</h1></body></html>";
+            string baseUri = "about:blank";
+
+            using (HTMLDocument document = new HTMLDocument(htmlContent, baseUri))
+            {
+                var validator = new WebAccessibility().CreateValidator();
+                ValidationResult validationResult = validator.Validate(document);
+
+                using (TcpClient client = new TcpClient("127.0.0.1", 9000))
+                using (NetworkStream networkStream = client.GetStream())
+                using (NetworkTextWriter writer = new NetworkTextWriter(networkStream))
+                {
+                    validationResult.SaveTo(writer, ValidationResultSaveFormat.XML);
+                    writer.Flush();
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.Error.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
deleted file mode 100644
index 8b8d8e3..0000000
--- a/web-accessibility/stream_validation_results_to_network_socket_using_custom_textwriter_for_remote_monitoring.cs
+++ /dev/null
@@ -1,82 +0,0 @@
-// 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-using-xslt-generate-human-readable-html-report.cs b/web-accessibility/transform-validation-json-output-using-xslt-generate-human-readable-html-report.cs
new file mode 100644
index 0000000..729996e
--- /dev/null
+++ b/web-accessibility/transform-validation-json-output-using-xslt-generate-human-readable-html-report.cs
@@ -0,0 +1,80 @@
+// Transform validation JSON output using XSLT to generate a human‑readable HTML report.
+
+using System;
+using System.IO;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Define file paths
+            string jsonPath = "validation.json";
+            string xsltPath = "report.xslt";
+            string outputPath = "report.html";
+
+            // Create sample JSON if it does not exist
+            if (!File.Exists(jsonPath))
+            {
+                string sampleJson = @"{
+  ""validationResult"": {
+    ""status"": ""Failed"",
+    ""issues"": [
+      { ""type"": ""Error"", ""message"": ""Missing alt attribute on img tag."" },
+      { ""type"": ""Warning"", ""message"": ""Low contrast text."" }
+    ]
+  }
+}";
+                File.WriteAllText(jsonPath, sampleJson);
+            }
+
+            // Create sample XSLT if it does not exist
+            if (!File.Exists(xsltPath))
+            {
+                string sampleXslt = @"<?xml version=""1.0"" encoding=""UTF-8""?>
+<xsl:stylesheet version=""1.0"" xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"">
+  <xsl:output method=""html"" indent=""yes""/>
+  <xsl:template match=""/"">
+    <html>
+      <head>
+        <title>Validation Report</title>
+        <style>
+          body { font-family: Arial, sans-serif; margin: 20px; }
+          .error { color: red; }
+          .warning { color: orange; }
+        </style>
+      </head>
+      <body>
+        <h1>Validation Report</h1>
+        <p>Status: <xsl:value-of select=""validationResult/status""/></p>
+        <h2>Issues</h2>
+        <ul>
+          <xsl:for-each select=""validationResult/issues/issue"">
+            <li class=""{translate(type, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')}"">
+              <strong><xsl:value-of select=""type""/></strong>: <xsl:value-of select=""message""/>
+            </li>
+          </xsl:for-each>
+        </ul>
+      </body>
+    </html>
+  </xsl:template>
+</xsl:stylesheet>";
+                File.WriteAllText(xsltPath, sampleXslt);
+            }
+
+            // Prepare template data and load options
+            Aspose.Html.Converters.TemplateData templateData = new Aspose.Html.Converters.TemplateData(jsonPath);
+            Aspose.Html.Loading.TemplateLoadOptions loadOptions = new Aspose.Html.Loading.TemplateLoadOptions();
+
+            // Convert JSON using XSLT to HTML
+            Aspose.Html.Converters.Converter.ConvertTemplate(xsltPath, templateData, loadOptions, outputPath);
+
+            Console.WriteLine("HTML report generated successfully at: " + Path.GetFullPath(outputPath));
+        }
+        catch (Exception ex)
+        {
+            Console.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
deleted file mode 100644
index be6cf3e..0000000
--- a/web-accessibility/transform_validation_json_output_xslt_generate_human_readable_html_report.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-// 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..5cef0c2
--- /dev/null
+++ b/web-accessibility/update-audio-element-include-track-element-captions-set-kind-captions-correctly.cs
@@ -0,0 +1,32 @@
+// Update an audio element to include a <track> element for captions and set kind="captions" correctly.
+
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            string htmlContent = "<!DOCTYPE html><html><body><audio id='myAudio' controls src='sample.mp3'></audio></body></html>";
+            string baseUri = "about:blank";
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, baseUri);
+            Aspose.Html.Collections.HTMLCollection audios = document.GetElementsByTagName("audio");
+            foreach (Aspose.Html.Dom.Element audio in audios)
+            {
+                Aspose.Html.Dom.Element track = document.CreateElement("track");
+                track.SetAttribute("src", "captions.vtt");
+                track.SetAttribute("kind", "captions");
+                track.SetAttribute("srclang", "en");
+                track.SetAttribute("label", "English");
+                audio.AppendChild(track);
+            }
+            string outputPath = "output.html";
+            document.Save(outputPath);
+        }
+        catch (System.Exception ex)
+        {
+            System.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..d7f46d4
--- /dev/null
+++ b/web-accessibility/use-online-color-contrast-checker-api-programmatically-verify-contrast-ratios-identified-elements.cs
@@ -0,0 +1,53 @@
+// Use the online Color Contrast Checker API to programmatically verify contrast ratios for identified elements.
+
+using System;
+using System.Net.Http;
+using System.Threading.Tasks;
+using Aspose.Html;
+using Aspose.Html.Dom;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            // Sample HTML content with a paragraph
+            string htmlContent = "<!DOCTYPE html><html><head><style>p{color:#FFFFFF;background-color:#0000FF;}</style></head><body></body></html>";
+
+            // Load HTML document from inline content
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank");
+
+            // Get the first paragraph element
+            Aspose.Html.HTMLElement paragraph = (Aspose.Html.HTMLElement)document.GetElementsByTagName("p")[0];
+
+            // Retrieve foreground and background colors
+            string foregroundColor = paragraph.Style.Color; // e.g., "#FFFFFF"
+            string backgroundColor = paragraph.Style.BackgroundColor; // e.g., "#0000FF"
+
+            // Prepare request to the online Color Contrast Checker API
+            // Example API endpoint (replace with actual if needed)
+            string apiUrl = $"https://webaim.org/resources/contrastchecker/?fcolor={foregroundColor.TrimStart('#')}&bcolor={backgroundColor.TrimStart('#')}&api";
+
+            // Call the API synchronously
+            using (HttpClient client = new HttpClient())
+            {
+                Task<string> responseTask = client.GetStringAsync(apiUrl);
+                responseTask.Wait();
+                string apiResult = responseTask.Result;
+
+                Console.WriteLine("Contrast Checker API response:");
+                Console.WriteLine(apiResult);
+            }
+
+            // Optionally, save the document to verify output
+            string outputPath = "output.html";
+            document.Save(outputPath);
+            Console.WriteLine($"HTML document saved to: {outputPath}");
+        }
+        catch (System.Exception ex)
+        {
+            Console.WriteLine(ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/use-stringbuilder-textwriter-capture-xml-validation-output-memory.cs b/web-accessibility/use-stringbuilder-textwriter-capture-xml-validation-output-memory.cs
new file mode 100644
index 0000000..c911de2
--- /dev/null
+++ b/web-accessibility/use-stringbuilder-textwriter-capture-xml-validation-output-memory.cs
@@ -0,0 +1,42 @@
+// Use a StringBuilder with a TextWriter to capture XML validation output in memory.
+
+using System;
+using System.Text;
+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</h1></body></html>";
+
+            // Load HTML document from string
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                // Create accessibility validator
+                Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+
+                // Perform validation
+                Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                // Capture XML validation output in memory
+                StringBuilder sb = new StringBuilder();
+                using (StringWriter sw = new StringWriter(sb))
+                {
+                    validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                }
+
+                // Output the captured XML
+                Console.WriteLine("Accessibility Validation Result (XML):");
+                Console.WriteLine(sb.ToString());
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("An error occurred: " + 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..05f20bd
--- /dev/null
+++ b/web-accessibility/use-validator-aspnet-core-controller-check-uploaded-html-files-multimedia-accessibility-before-storage.cs
@@ -0,0 +1,48 @@
+// Use the validator in an ASP.NET Core controller to check uploaded HTML files for multimedia accessibility before storage.
+
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            // Create a temporary HTML file with multimedia content
+            string tempPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "sample.html");
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><video src=\"sample.mp4\"></video></body></html>";
+            System.IO.File.WriteAllText(tempPath, htmlContent, System.Text.Encoding.UTF8);
+
+            // Initialize WebAccessibility
+            Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+            // Obtain a guideline (example: principle \"Multimedia\", guideline \"Captions\")
+            Aspose.Html.Accessibility.Guideline guideline = webAccessibility.Rules.GetPrinciple("Multimedia").GetGuideline("Captions");
+
+            // Create a validator with all validation options
+            Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(guideline, Aspose.Html.Accessibility.ValidationBuilder.All);
+
+            // Load the HTML document from the file
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(tempPath);
+
+            // Perform validation
+            Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+            if (!validationResult.Success)
+            {
+                System.Console.WriteLine("Validation failed.");
+            }
+            else
+            {
+                System.Console.WriteLine("Validation succeeded. No accessibility issues found.");
+            }
+
+            // Clean up temporary file
+            System.IO.File.Delete(tempPath);
+        }
+        catch (System.Exception ex)
+        {
+            System.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..87f341e
--- /dev/null
+++ b/web-accessibility/use-validator-azure-devops-pipeline-task-publish-validation-report-build-artifact.cs
@@ -0,0 +1,48 @@
+// 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(string[] args)
+    {
+        try
+        {
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1></body></html>";
+
+            // Load HTML document from inline content
+            Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank");
+
+            // Create accessibility validator with 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);
+
+            // Output validation details if any rule failed
+            if (!validationResult.Success)
+            {
+                foreach (Aspose.Html.Accessibility.Results.RuleValidationResult detail in validationResult.Details)
+                {
+                    Console.WriteLine($"Rule: {detail.Rule.Code} - {detail.Rule.Description} - Success: {detail.Success}");
+                }
+            }
+
+            // Save validation report as XML file (artifact)
+            using (System.IO.StringWriter sw = new System.IO.StringWriter())
+            {
+                validationResult.SaveTo(sw, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                string reportXml = sw.ToString();
+                string reportPath = "validation_report.xml";
+                System.IO.File.WriteAllText(reportPath, reportXml);
+                Console.WriteLine($"Validation report saved to {reportPath}");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/use-validator-console-application-process-list-html-file-paths-command-line-arguments.cs b/web-accessibility/use-validator-console-application-process-list-html-file-paths-command-line-arguments.cs
new file mode 100644
index 0000000..7101d2a
--- /dev/null
+++ b/web-accessibility/use-validator-console-application-process-list-html-file-paths-command-line-arguments.cs
@@ -0,0 +1,39 @@
+// Use the validator in a console application to process a list of HTML file paths via command‑line arguments.
+
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            string[] filePaths = args.Length > 0 ? args : new string[] { "sample.html" };
+            foreach (string path in filePaths)
+            {
+                if (!System.IO.File.Exists(path))
+                {
+                    if (path == "sample.html")
+                    {
+                        System.IO.File.WriteAllText(path, "<!DOCTYPE html><html><head><title>Sample</title></head><body><p>Hello World</p></body></html>");
+                    }
+                    else
+                    {
+                        System.Console.WriteLine($"File not found: {path}");
+                        continue;
+                    }
+                }
+
+                var document = new Aspose.Html.HTMLDocument(path);
+                var validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+                var validationResult = validator.Validate(document);
+                System.Console.WriteLine($"Validation result for '{path}': Success = {validationResult.Success}");
+                System.Console.WriteLine(validationResult.SaveToString());
+            }
+        }
+        catch (System.Exception ex)
+        {
+            System.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/use-validator-in-github-actions-workflow-to-automatically-fail-builds-on-caption-issues-detection.cs
similarity index 69%
rename from web-accessibility/create_validator_instance_using_createvalidator_before_loading_html_document_for_accessibility.cs
rename to web-accessibility/use-validator-in-github-actions-workflow-to-automatically-fail-builds-on-caption-issues-detection.cs
index 7d3a59e..2480f2b 100644
--- a/web-accessibility/create_validator_instance_using_createvalidator_before_loading_html_document_for_accessibility.cs
+++ b/web-accessibility/use-validator-in-github-actions-workflow-to-automatically-fail-builds-on-caption-issues-detection.cs
@@ -1,8 +1,6 @@
-// Create a validator instance using CreateValidator() before loading any HTML document for accessibility.
+// Use the validator in a GitHub Actions workflow to automatically fail builds when caption issues are detected.
 
 using System;
-using System.IO;
-using System.Text;
 
 class Program
 {
@@ -10,18 +8,17 @@ 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);
+            // Sample HTML content with a potential caption issue
+            string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><figure><img src='image.png' alt='Sample image'></figure></body></html>";
 
             // 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))
+            // Load HTML document from inline content
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
             {
+                // Perform validation
                 Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
 
                 if (validationResult.Success)
@@ -42,12 +39,6 @@ static void Main()
                     }
                 }
             }
-
-            // Clean up temporary file
-            if (File.Exists(tempFilePath))
-            {
-                File.Delete(tempFilePath);
-            }
         }
         catch (Exception ex)
         {
diff --git a/web-accessibility/use-validator-within-unit-test-assert-no-multimedia-accessibility-issues-sample-html.cs b/web-accessibility/use-validator-within-unit-test-assert-no-multimedia-accessibility-issues-sample-html.cs
new file mode 100644
index 0000000..c74347c
--- /dev/null
+++ b/web-accessibility/use-validator-within-unit-test-assert-no-multimedia-accessibility-issues-sample-html.cs
@@ -0,0 +1,53 @@
+// Use the validator within a unit test to assert that no multimedia accessibility issues exist in sample HTML.
+
+using System;
+
+namespace AccessibilityValidatorExample
+{
+    class Program
+    {
+        static void Main()
+        {
+            try
+            {
+                // Sample HTML content with multimedia and proper accessibility attributes
+                string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><video src=\"sample.mp4\" controls><track kind=\"captions\" src=\"captions.vtt\" srclang=\"en\" label=\"English\" default></track></video></body></html>";
+
+                // Create WebAccessibility instance
+                Aspose.Html.Accessibility.WebAccessibility webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+
+                // Create validator for all rules
+                Aspose.Html.Accessibility.AccessibilityValidator validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+
+                // Load HTML document from inline content
+                using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+                {
+                    Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                    if (validationResult.Success)
+                    {
+                        Console.WriteLine("Accessibility validation passed. No multimedia issues found.");
+                    }
+                    else
+                    {
+                        Console.WriteLine("Accessibility validation failed. Issues:");
+                        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/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
deleted file mode 100644
index 57f1a77..0000000
--- a/web-accessibility/use_online_color_contrast_checker_api_programmatically_verify_contrast_ratios_identified_elements.cs
+++ /dev/null
@@ -1,60 +0,0 @@
-// 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
deleted file mode 100644
index 78a7d33..0000000
--- a/web-accessibility/use_stringbuilder_textwriter_capture_xml_validation_output_in_memory.cs
+++ /dev/null
@@ -1,222 +0,0 @@
-// 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_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
deleted file mode 100644
index fc14c5d..0000000
--- a/web-accessibility/use_validator_within_unit_test_assert_no_multimedia_accessibility_issues_in_sample_html.cs
+++ /dev/null
@@ -1,84 +0,0 @@
-// 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..8530af2
--- /dev/null
+++ b/web-accessibility/validate-html-documents-retrieved-from-remote-url-loading-content-into-validator.cs
@@ -0,0 +1,42 @@
+// Validate HTML documents retrieved from a remote URL by loading the URL content into the validator.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+
+public class Program
+{
+    public static void Main()
+    {
+        try
+        {
+            List<string> urls = new List<string> { "https://example.com", "https://www.w3.org/TR/WCAG20/" };
+            string outputDir = "ValidationResults";
+            Directory.CreateDirectory(outputDir);
+
+            WebAccessibility webAccessibility = new WebAccessibility();
+            AccessibilityValidator validator = webAccessibility.CreateValidator(ValidationBuilder.All);
+
+            int index = 1;
+            foreach (string url in urls)
+            {
+                using (HTMLDocument document = new HTMLDocument(url))
+                {
+                    ValidationResult validationResult = validator.Validate(document);
+                    string outputPath = Path.Combine(outputDir, $"validation_result_{index}.xml");
+                    File.WriteAllText(outputPath, validationResult.ToString());
+                }
+                index++;
+            }
+
+            Console.WriteLine("Validation completed successfully.");
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/validate-html-generated-razor-view-runtime-log-accessibility-issues.cs b/web-accessibility/validate-html-generated-razor-view-runtime-log-accessibility-issues.cs
new file mode 100644
index 0000000..c895218
--- /dev/null
+++ b/web-accessibility/validate-html-generated-razor-view-runtime-log-accessibility-issues.cs
@@ -0,0 +1,48 @@
+// Validate HTML generated by a Razor view at runtime and log any accessibility issues detected.
+
+using System;
+
+namespace AsposeHtmlAccessibilityExample
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            try
+            {
+                // Simulated Razor view output
+                string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><img src='image.jpg'></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, "about:blank"))
+                {
+                    Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                    if (validationResult.Success)
+                    {
+                        Console.WriteLine("No accessibility issues detected.");
+                    }
+                    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/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
deleted file mode 100644
index 2400373..0000000
--- a/web-accessibility/validate_html_documents_retrieved_from_remote_url_loading_content_into_validator.cs
+++ /dev/null
@@ -1,98 +0,0 @@
-// 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/verify-each-track-element-includes-valid-srclang-attribute-accessibility-standards.cs b/web-accessibility/verify-each-track-element-includes-valid-srclang-attribute-accessibility-standards.cs
new file mode 100644
index 0000000..40d30c9
--- /dev/null
+++ b/web-accessibility/verify-each-track-element-includes-valid-srclang-attribute-accessibility-standards.cs
@@ -0,0 +1,56 @@
+// Verify that each <track> element includes a valid srclang attribute to meet accessibility standards.
+
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        try
+        {
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body>" +
+                                 "<video controls>" +
+                                 "<source src=\"movie.mp4\" type=\"video/mp4\">" +
+                                 "<track kind=\"subtitles\" src=\"subtitles_en.vtt\" srclang=\"en\" label=\"English\">" +
+                                 "<track kind=\"subtitles\" src=\"subtitles_fr.vtt\" label=\"French\">" + // Missing srclang
+                                 "</video>" +
+                                 "</body></html>";
+
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                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 srclangValue = element.GetAttribute("srclang");
+                                    System.Console.WriteLine($"Tag: {tagName}, srclang: {srclangValue}, Message: {techResult.Error.ErrorMessage}");
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    System.Console.WriteLine("All <track> elements have valid srclang attributes.");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Console.WriteLine($"Error: {ex.Message}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/write-formatted-validation-string-to-text-file-archival-reporting.cs b/web-accessibility/write-formatted-validation-string-to-text-file-archival-reporting.cs
new file mode 100644
index 0000000..70281cc
--- /dev/null
+++ b/web-accessibility/write-formatted-validation-string-to-text-file-archival-reporting.cs
@@ -0,0 +1,53 @@
+// Write the formatted validation string to a text file for archival and reporting.
+
+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
+        {
+            // Sample HTML content
+            string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1></body></html>";
+
+            // Load HTML document from inline content
+            using (HTMLDocument document = new HTMLDocument(htmlContent, "about:blank"))
+            {
+                // Create accessibility validator
+                WebAccessibility webAccessibility = new WebAccessibility();
+                AccessibilityValidator validator = webAccessibility.CreateValidator();
+
+                // Perform validation
+                ValidationResult validationResult = validator.Validate(document);
+
+                // Save validation result to XML string
+                string xmlResult;
+                using (StringWriter sw = new StringWriter())
+                {
+                    validationResult.SaveTo(sw, ValidationResultSaveFormat.XML);
+                    xmlResult = sw.ToString();
+                }
+
+                // Write XML string to file
+                string outputPath = "validation_report.xml";
+                using (FileStream fileStream = new FileStream(outputPath, FileMode.Create, FileAccess.Write))
+                using (StreamWriter writer = new StreamWriter(fileStream))
+                {
+                    writer.Write(xmlResult);
+                }
+
+                Console.WriteLine("Validation report saved to: " + Path.GetFullPath(outputPath));
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/write-method-return-warning-counts-grouped-by-target-element-type-analysis.cs b/web-accessibility/write-method-return-warning-counts-grouped-by-target-element-type-analysis.cs
new file mode 100644
index 0000000..8635ca2
--- /dev/null
+++ b/web-accessibility/write-method-return-warning-counts-grouped-by-target-element-type-analysis.cs
@@ -0,0 +1,61 @@
+// Write a method that returns warning counts grouped by each target element type for analysis.
+
+namespace AsposeHtmlAccessibilityExample
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            try
+            {
+                string html = "<!DOCTYPE html><html><head><title>Test</title></head><body><img src='image.png'><a href='#'>Link</a></body></html>";
+                var counts = GetWarningCounts(html);
+                foreach (var kvp in counts)
+                {
+                    System.Console.WriteLine($"Tag: {kvp.Key}, Warning Count: {kvp.Value}");
+                }
+            }
+            catch (System.Exception ex)
+            {
+                System.Console.WriteLine($"Error: {ex.Message}");
+            }
+        }
+
+        static System.Collections.Generic.Dictionary<string, int> GetWarningCounts(string htmlContent)
+        {
+            var result = new System.Collections.Generic.Dictionary<string, int>();
+            var webAccessibility = new Aspose.Html.Accessibility.WebAccessibility();
+            var validator = webAccessibility.CreateValidator(Aspose.Html.Accessibility.ValidationBuilder.All);
+            using (var document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                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;
+                                    var tagName = element.TagName;
+                                    if (result.ContainsKey(tagName))
+                                    {
+                                        result[tagName] = result[tagName] + 1;
+                                    }
+                                    else
+                                    {
+                                        result[tagName] = 1;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return result;
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/write-method-returns-list-error-messages-specified-rule-identifier.cs b/web-accessibility/write-method-returns-list-error-messages-specified-rule-identifier.cs
new file mode 100644
index 0000000..0b8e902
--- /dev/null
+++ b/web-accessibility/write-method-returns-list-error-messages-specified-rule-identifier.cs
@@ -0,0 +1,55 @@
+// Write a method that returns a list of error messages for a specified rule identifier.
+
+using System;
+using System.Collections.Generic;
+using Aspose.Html.Accessibility;
+using Aspose.Html.Accessibility.Results;
+using Aspose.Html;
+
+class Program
+{
+    static void Main()
+    {
+        try
+        {
+            var errors = GetErrorMessages("example-rule-id");
+            foreach (string msg in errors)
+            {
+                Console.WriteLine(msg);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+
+    static List<string> GetErrorMessages(string ruleId)
+    {
+        var messages = new List<string>();
+
+        // Initialize WebAccessibility and validator
+        WebAccessibility webAccessibility = new WebAccessibility();
+        AccessibilityValidator validator = webAccessibility.CreateValidator(ValidationBuilder.All);
+
+        // Sample HTML content
+        string htmlContent = "<!DOCTYPE html><html><head><title>Sample</title></head><body><h1>Sample</h1></body></html>";
+        HTMLDocument document = new HTMLDocument(htmlContent, "about:blank");
+
+        // Perform validation
+        ValidationResult validationResult = validator.Validate(document);
+
+        // Iterate over rule results
+        foreach (RuleValidationResult ruleResult in validationResult.Details)
+        {
+            // Filter by rule identifier if possible (property not exposed in this example)
+            // Collect error messages for failed rules
+            if (!ruleResult.Success)
+            {
+                messages.Add("Validation error in a rule.");
+            }
+        }
+
+        return messages;
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/write-validation-results-to-json-file-using-validationresult-savetojson-format.cs b/web-accessibility/write-validation-results-to-json-file-using-validationresult-savetojson-format.cs
new file mode 100644
index 0000000..e2ca624
--- /dev/null
+++ b/web-accessibility/write-validation-results-to-json-file-using-validationresult-savetojson-format.cs
@@ -0,0 +1,32 @@
+// 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 htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello</h1></body></html>";
+            using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+            {
+                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);
+                    string json = sw.ToString();
+                    File.WriteAllText("validation_result.json", json);
+                }
+            }
+
+            Console.WriteLine("Validation results saved to validation_result.json");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Error: " + ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/web-accessibility/write-validation-results-to-xml-file-using-validationresult-savetoxml-format.cs b/web-accessibility/write-validation-results-to-xml-file-using-validationresult-savetoxml-format.cs
new file mode 100644
index 0000000..dd516d0
--- /dev/null
+++ b/web-accessibility/write-validation-results-to-xml-file-using-validationresult-savetoxml-format.cs
@@ -0,0 +1,35 @@
+// Write validation results to an XML file by calling ValidationResult.SaveTo with Xml format.
+
+using System;
+using System.IO;
+
+namespace AsposeHtmlAccessibilityExample
+{
+    class Program
+    {
+        static void Main()
+        {
+            try
+            {
+                string htmlContent = "<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Hello World</h1></body></html>";
+                using (Aspose.Html.HTMLDocument document = new Aspose.Html.HTMLDocument(htmlContent, "about:blank"))
+                {
+                    Aspose.Html.Accessibility.AccessibilityValidator validator = new Aspose.Html.Accessibility.WebAccessibility().CreateValidator();
+                    Aspose.Html.Accessibility.Results.ValidationResult validationResult = validator.Validate(document);
+
+                    string outputPath = "validation_result.xml";
+                    using (StreamWriter writer = new StreamWriter(outputPath))
+                    {
+                        validationResult.SaveTo(writer, Aspose.Html.Accessibility.Saving.ValidationResultSaveFormat.XML);
+                    }
+
+                    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_method_returning_error_messages_for_rule_identifier.cs b/web-accessibility/write_method_returning_error_messages_for_rule_identifier.cs
deleted file mode 100644
index 9fad097..0000000
--- a/web-accessibility/write_method_returning_error_messages_for_rule_identifier.cs
+++ /dev/null
@@ -1,117 +0,0 @@
-// 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
deleted file mode 100644
index dc1651c..0000000
--- a/web-accessibility/write_method_returns_warning_counts_grouped_target_element_type_analysis.cs
+++ /dev/null
@@ -1,88 +0,0 @@
-// 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