Accessibility Errors and Warnings in C#

Use Aspose.HTML for .NET to collect accessibility errors and warnings in C#. After validation, inspect IError, Target, TargetTypes, failed technique results, messages, and the source HTML or CSS element that caused the issue.

Detecting errors helps identify barriers that may prevent people with disabilities from using and interacting with web content effectively. Errors and warnings guide what must be addressed to improve web accessibility. They serve as a roadmap for developers and designers to make necessary changes.

IError

The IError is a public interface containing information about the validation error. This means an erroneous check, i.e., the rule was not passed – and its result does not match Accessibility.

Property	Description
ErrorMessage	Returns a string message of the error or warning.
Target	Returns an HTML or CSS element where the error was found. The returned object is of type Target.
ErrorTypeName	Description of the presentation of the error object. It has two options “Error” or “Warning”.
ErrorType	Returns error type numeric value.
Success	Result of this object.

IError object has such meanings:

* ErrorType = 1 and Success = false – this means that the error is critical, and the result of the check is not performed.
* ErrorType = 2 and Success = true – this means that the error is not critical but has an informational character and displays hints for possible improvement. 

The type of error is determined by the type of technique:

• If a technique fails to meet a required success criterion, and that criterion is required to meet it, the result will be marked as a critical failure, resulting in ErrorType=1 and Success=false, and it is an Error.
• If a technique is not strictly required, or if the issue is more of a best practice or improvement suggestion than a hard violation of the rules, it will be marked as ErrorType=2 and Success=true, and it is a Warning.

Target

The Target is a public class that contains item of HTML or CSS element of document where the error was found.

Property	Description
Item	Returns Object of html or css element.
TargetType	Returns the type of the contained object. Object type of TargetTypes.

TargetTypes

The TargetTypes Enum of element types from the HTML document containing the error:

Value	Description
HTMLElement	The element containing the HTMLElement from document.
CSSStyleRule	The element containing the CSSStyleRule from document.
CSSStyleSheet	The element containing the CSSStyleSheet from document.

Let’s look at the C# code for iterating through the web accessibility check results, paying particular attention to the failure criteria and the details of the methods that report errors. Example of getting errors details and elements of an HTML document:

1. Use the RuleValidationResult class and iterate through the ruleResult objects contained within validationResult.Details. These represent different accessibility criteria.
2. Print the code and description of the criterion and whether it was successful or not. For this, use the Code and Description properties of the IRule interface.
3. Use the Success property to check the criteria.
4. Use the ITechniqueResult objects – ruleDetail contained within ruleResult.Errors. The ITechniqueResult objects represent individual rule results for the criterion that reported errors.
5. Print the information about the method, including the method code, success status, and description.
6. Use the IError property to obtain the error object from the ruleDetail. The ruleDetail represents a specific accessibility issue, and the error object contains information about that issue.
7. Use the Target property to retrieve the target object associated with the error. The target object typically represents the specific HTML element, CSS rule, or other content that triggered the accessibility error.
8. Print information about the error. It includes the error type (error.ErrorTypeName) and the error message (error.ErrorMessage).
9. Use the TargetType property of the Target class to check the type of the target object. Depending on the type of the target object, specific information is extracted and printed to the console.

// Check HTML for WCAG compliance and output failed rule codes and error messages

// Initialize a webAccessibility container
WebAccessibility webAccessibility = new WebAccessibility();

// Create an accessibillity validator with static instance for all rules from repository that match the builder settings
AccessibilityValidator validator = webAccessibility.CreateValidator(ValidationBuilder.All);

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

// Initialize an object of the HTMLDocument class
using (HTMLDocument document = new HTMLDocument(documentPath))
{
    // Check the document
    ValidationResult validationResult = validator.Validate(document);

    foreach (RuleValidationResult ruleResult in validationResult.Details)
    {
        //  list only unsuccessful rule
        if (!ruleResult.Success)
        {
            // print the code and description of the rule
            Console.WriteLine("{0}:{1} = {2}", ruleResult.Rule.Code, ruleResult.Rule.Description, ruleResult.Success);
            // print the results of methods with errors
            foreach (ITechniqueResult ruleDetail in ruleResult.Errors)
            {
                // print the code and description of the method
                StringBuilder str = new StringBuilder(string.Format("\n{0}: {1} - {2}",
                                                           ruleDetail.Rule.Code, ruleDetail.Success,
                                                           ruleDetail.Rule.Description));
                // get an error object 
                IError error = ruleDetail.Error;
                // get a target object 
                Target target = error.Target;
                // get error type and message 
                str.AppendFormat("\n\n\t{0} : {1}", error.ErrorTypeName, error.ErrorMessage);
                if (target != null)
                {
                    // Checking the type of the contained object for casting and working with it
                    if (target.TargetType == TargetTypes.CSSStyleRule)
                    {
                        ICSSStyleRule cssRule = (ICSSStyleRule)target.Item;
                        str.AppendFormat("\n\n\t{0}", cssRule.CSSText);
                    }
                    if (ruleDetail.Error.Target.TargetType == TargetTypes.CSSStyleSheet)
                        str.AppendFormat("\n\n\t{0}", ((ICSSStyleSheet)target.Item).Title);

                    if (ruleDetail.Error.Target.TargetType == TargetTypes.HTMLElement)
                        str.AppendFormat("\n\n\t{0}", ((HTMLElement)target.Item).OuterHTML);
                }
                Console.WriteLine(str.ToString());
            }
        }
    }
}

FAQ

What is the difference between an accessibility error and warning?

An error represents a failed required check. A warning usually reports a non-critical issue or improvement hint while preserving the success state of that specific result.

How do I find the HTML element that caused an issue?

Use the IError.Target property. The returned Target object indicates whether the source is an HTML element, CSS rule, or CSS stylesheet.

Should warnings be treated as failures?

Not always. Warnings can indicate improvement opportunities or non-critical findings, but they should still be reviewed before treating a page as production-ready.

Related Articles

• Validation Results in C# – inspect ValidationResult, RuleValidationResult, and technique details.
• Save Accessibility Validation Results in C# – save results as text, JSON, or XML.
• Accessibility Validator in C# – create validators and configure accessibility checks.
• Web Accessibility Rules in C# – work with principles, guidelines, criteria, and techniques.
• How to Improve Website Accessibility – improve alt text, captions, semantic HTML, keyboard access, and forms.

You can also use the online Web Accessibility Checker to scan a page before inspecting detailed errors in code.